1 /* FR30 specific functions. 2 Copyright (C) 1998-2018 Free Software Foundation, Inc. 3 Contributed by Cygnus Solutions. 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public 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 /*{{{ Includes */ 22 23 #define IN_TARGET_CODE 1 24 25 #include "config.h" 26 #include "system.h" 27 #include "coretypes.h" 28 #include "backend.h" 29 #include "target.h" 30 #include "rtl.h" 31 #include "tree.h" 32 #include "stringpool.h" 33 #include "attribs.h" 34 #include "df.h" 35 #include "memmodel.h" 36 #include "emit-rtl.h" 37 #include "stor-layout.h" 38 #include "varasm.h" 39 #include "output.h" 40 #include "expr.h" 41 #include "builtins.h" 42 43 /* This file should be included last. */ 44 #include "target-def.h" 45 46 /*}}}*/ 47 /*{{{ Function Prologues & Epilogues */ 48 49 /* The FR30 stack looks like this: 50 51 Before call After call 52 FP ->| | | | 53 +-----------------------+ +-----------------------+ high 54 | | | | memory 55 | local variables, | | local variables, | 56 | reg save area, etc. | | reg save area, etc. | 57 | | | | 58 +-----------------------+ +-----------------------+ 59 | | | | 60 | args to the func that | | args to this func. | 61 | is being called that | | | 62 SP ->| do not fit in regs | | | 63 +-----------------------+ +-----------------------+ 64 | args that used to be | \ 65 | in regs; only created | | pretend_size 66 AP-> | for vararg funcs | / 67 +-----------------------+ 68 | | \ 69 | register save area | | 70 | | | 71 +-----------------------+ | reg_size 72 | return address | | 73 +-----------------------+ | 74 FP ->| previous frame ptr | / 75 +-----------------------+ 76 | | \ 77 | local variables | | var_size 78 | | / 79 +-----------------------+ 80 | | \ 81 low | room for args to | | 82 memory | other funcs called | | args_size 83 | from this one | | 84 SP ->| | / 85 +-----------------------+ 86 87 Note, AP is a fake hard register. It will be eliminated in favor of 88 SP or FP as appropriate. 89 90 Note, Some or all of the stack sections above may be omitted if they 91 are not needed. */ 92 93 /* Structure to be filled in by fr30_compute_frame_size() with register 94 save masks, and offsets for the current function. */ 95 struct fr30_frame_info 96 { 97 unsigned int total_size; /* # Bytes that the entire frame takes up. */ 98 unsigned int pretend_size; /* # Bytes we push and pretend caller did. */ 99 unsigned int args_size; /* # Bytes that outgoing arguments take up. */ 100 unsigned int reg_size; /* # Bytes needed to store regs. */ 101 unsigned int var_size; /* # Bytes that variables take up. */ 102 unsigned int frame_size; /* # Bytes in current frame. */ 103 unsigned int gmask; /* Mask of saved registers. */ 104 unsigned int save_fp; /* Nonzero if frame pointer must be saved. */ 105 unsigned int save_rp; /* Nonzero if return pointer must be saved. */ 106 int initialised; /* Nonzero if frame size already calculated. */ 107 }; 108 109 /* Current frame information calculated by fr30_compute_frame_size(). */ 110 static struct fr30_frame_info current_frame_info; 111 112 /* Zero structure to initialize current_frame_info. */ 113 static struct fr30_frame_info zero_frame_info; 114 115 static void fr30_setup_incoming_varargs (cumulative_args_t, machine_mode, 116 tree, int *, int); 117 static bool fr30_must_pass_in_stack (machine_mode, const_tree); 118 static int fr30_arg_partial_bytes (cumulative_args_t, machine_mode, 119 tree, bool); 120 static rtx fr30_function_arg (cumulative_args_t, machine_mode, 121 const_tree, bool); 122 static void fr30_function_arg_advance (cumulative_args_t, machine_mode, 123 const_tree, bool); 124 static bool fr30_frame_pointer_required (void); 125 static rtx fr30_function_value (const_tree, const_tree, bool); 126 static rtx fr30_libcall_value (machine_mode, const_rtx); 127 static bool fr30_function_value_regno_p (const unsigned int); 128 static bool fr30_can_eliminate (const int, const int); 129 static void fr30_asm_trampoline_template (FILE *); 130 static void fr30_trampoline_init (rtx, tree, rtx); 131 static int fr30_num_arg_regs (machine_mode, const_tree); 132 133 #define FRAME_POINTER_MASK (1 << (FRAME_POINTER_REGNUM)) 134 #define RETURN_POINTER_MASK (1 << (RETURN_POINTER_REGNUM)) 135 136 /* Tell prologue and epilogue if register REGNO should be saved / restored. 137 The return address and frame pointer are treated separately. 138 Don't consider them here. */ 139 #define MUST_SAVE_REGISTER(regno) \ 140 ( (regno) != RETURN_POINTER_REGNUM \ 141 && (regno) != FRAME_POINTER_REGNUM \ 142 && df_regs_ever_live_p (regno) \ 143 && ! call_used_regs [regno] ) 144 145 #define MUST_SAVE_FRAME_POINTER (df_regs_ever_live_p (FRAME_POINTER_REGNUM) || frame_pointer_needed) 146 #define MUST_SAVE_RETURN_POINTER (df_regs_ever_live_p (RETURN_POINTER_REGNUM) || crtl->profile) 147 148 #if UNITS_PER_WORD == 4 149 #define WORD_ALIGN(SIZE) (((SIZE) + 3) & ~3) 150 #endif 151 152 /* Initialize the GCC target structure. */ 153 #undef TARGET_ASM_ALIGNED_HI_OP 154 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t" 155 #undef TARGET_ASM_ALIGNED_SI_OP 156 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t" 157 158 #undef TARGET_PROMOTE_PROTOTYPES 159 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true 160 #undef TARGET_PASS_BY_REFERENCE 161 #define TARGET_PASS_BY_REFERENCE hook_pass_by_reference_must_pass_in_stack 162 #undef TARGET_ARG_PARTIAL_BYTES 163 #define TARGET_ARG_PARTIAL_BYTES fr30_arg_partial_bytes 164 #undef TARGET_FUNCTION_ARG 165 #define TARGET_FUNCTION_ARG fr30_function_arg 166 #undef TARGET_FUNCTION_ARG_ADVANCE 167 #define TARGET_FUNCTION_ARG_ADVANCE fr30_function_arg_advance 168 169 #undef TARGET_FUNCTION_VALUE 170 #define TARGET_FUNCTION_VALUE fr30_function_value 171 #undef TARGET_LIBCALL_VALUE 172 #define TARGET_LIBCALL_VALUE fr30_libcall_value 173 #undef TARGET_FUNCTION_VALUE_REGNO_P 174 #define TARGET_FUNCTION_VALUE_REGNO_P fr30_function_value_regno_p 175 176 #undef TARGET_SETUP_INCOMING_VARARGS 177 #define TARGET_SETUP_INCOMING_VARARGS fr30_setup_incoming_varargs 178 #undef TARGET_MUST_PASS_IN_STACK 179 #define TARGET_MUST_PASS_IN_STACK fr30_must_pass_in_stack 180 181 #undef TARGET_FRAME_POINTER_REQUIRED 182 #define TARGET_FRAME_POINTER_REQUIRED fr30_frame_pointer_required 183 184 #undef TARGET_CAN_ELIMINATE 185 #define TARGET_CAN_ELIMINATE fr30_can_eliminate 186 187 #undef TARGET_LRA_P 188 #define TARGET_LRA_P hook_bool_void_false 189 190 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE 191 #define TARGET_ASM_TRAMPOLINE_TEMPLATE fr30_asm_trampoline_template 192 #undef TARGET_TRAMPOLINE_INIT 193 #define TARGET_TRAMPOLINE_INIT fr30_trampoline_init 194 195 #undef TARGET_CONSTANT_ALIGNMENT 196 #define TARGET_CONSTANT_ALIGNMENT constant_alignment_word_strings 197 198 struct gcc_target targetm = TARGET_INITIALIZER; 199 200 201 /* Worker function for TARGET_CAN_ELIMINATE. */ 202 203 bool 204 fr30_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to) 205 { 206 return (to == FRAME_POINTER_REGNUM || ! frame_pointer_needed); 207 } 208 209 /* Returns the number of bytes offset between FROM_REG and TO_REG 210 for the current function. As a side effect it fills in the 211 current_frame_info structure, if the data is available. */ 212 unsigned int 213 fr30_compute_frame_size (int from_reg, int to_reg) 214 { 215 int regno; 216 unsigned int return_value; 217 unsigned int var_size; 218 unsigned int args_size; 219 unsigned int pretend_size; 220 unsigned int reg_size; 221 unsigned int gmask; 222 223 var_size = WORD_ALIGN (get_frame_size ()); 224 args_size = WORD_ALIGN (crtl->outgoing_args_size); 225 pretend_size = crtl->args.pretend_args_size; 226 227 reg_size = 0; 228 gmask = 0; 229 230 /* Calculate space needed for registers. */ 231 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno ++) 232 { 233 if (MUST_SAVE_REGISTER (regno)) 234 { 235 reg_size += UNITS_PER_WORD; 236 gmask |= 1 << regno; 237 } 238 } 239 240 current_frame_info.save_fp = MUST_SAVE_FRAME_POINTER; 241 current_frame_info.save_rp = MUST_SAVE_RETURN_POINTER; 242 243 reg_size += (current_frame_info.save_fp + current_frame_info.save_rp) 244 * UNITS_PER_WORD; 245 246 /* Save computed information. */ 247 current_frame_info.pretend_size = pretend_size; 248 current_frame_info.var_size = var_size; 249 current_frame_info.args_size = args_size; 250 current_frame_info.reg_size = reg_size; 251 current_frame_info.frame_size = args_size + var_size; 252 current_frame_info.total_size = args_size + var_size + reg_size + pretend_size; 253 current_frame_info.gmask = gmask; 254 current_frame_info.initialised = reload_completed; 255 256 /* Calculate the required distance. */ 257 return_value = 0; 258 259 if (to_reg == STACK_POINTER_REGNUM) 260 return_value += args_size + var_size; 261 262 if (from_reg == ARG_POINTER_REGNUM) 263 return_value += reg_size; 264 265 return return_value; 266 } 267 268 /* Called after register allocation to add any instructions needed for the 269 prologue. Using a prologue insn is favored compared to putting all of the 270 instructions in output_function_prologue(), since it allows the scheduler 271 to intermix instructions with the saves of the caller saved registers. In 272 some cases, it might be necessary to emit a barrier instruction as the last 273 insn to prevent such scheduling. */ 274 275 void 276 fr30_expand_prologue (void) 277 { 278 int regno; 279 rtx insn; 280 281 if (! current_frame_info.initialised) 282 fr30_compute_frame_size (0, 0); 283 284 /* This cases shouldn't happen. Catch it now. */ 285 gcc_assert (current_frame_info.total_size || !current_frame_info.gmask); 286 287 /* Allocate space for register arguments if this is a variadic function. */ 288 if (current_frame_info.pretend_size) 289 { 290 int regs_to_save = current_frame_info.pretend_size / UNITS_PER_WORD; 291 292 /* Push argument registers into the pretend arg area. */ 293 for (regno = FIRST_ARG_REGNUM + FR30_NUM_ARG_REGS; regno --, regs_to_save --;) 294 { 295 insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno))); 296 RTX_FRAME_RELATED_P (insn) = 1; 297 } 298 } 299 300 if (current_frame_info.gmask) 301 { 302 /* Save any needed call-saved regs. */ 303 for (regno = STACK_POINTER_REGNUM; regno--;) 304 { 305 if ((current_frame_info.gmask & (1 << regno)) != 0) 306 { 307 insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno))); 308 RTX_FRAME_RELATED_P (insn) = 1; 309 } 310 } 311 } 312 313 /* Save return address if necessary. */ 314 if (current_frame_info.save_rp) 315 { 316 insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, 317 RETURN_POINTER_REGNUM))); 318 RTX_FRAME_RELATED_P (insn) = 1; 319 } 320 321 /* Save old frame pointer and create new one, if necessary. */ 322 if (current_frame_info.save_fp) 323 { 324 if (current_frame_info.frame_size < ((1 << 10) - UNITS_PER_WORD)) 325 { 326 int enter_size = current_frame_info.frame_size + UNITS_PER_WORD; 327 rtx pattern; 328 329 insn = emit_insn (gen_enter_func (GEN_INT (enter_size))); 330 RTX_FRAME_RELATED_P (insn) = 1; 331 332 pattern = PATTERN (insn); 333 334 /* Also mark all 3 subexpressions as RTX_FRAME_RELATED_P. */ 335 if (GET_CODE (pattern) == PARALLEL) 336 { 337 int x; 338 for (x = XVECLEN (pattern, 0); x--;) 339 { 340 rtx part = XVECEXP (pattern, 0, x); 341 342 /* One of the insns in the ENTER pattern updates the 343 frame pointer. If we do not actually need the frame 344 pointer in this function then this is a side effect 345 rather than a desired effect, so we do not mark that 346 insn as being related to the frame set up. Doing this 347 allows us to compile the crash66.C test file in the 348 G++ testsuite. */ 349 if (! frame_pointer_needed 350 && GET_CODE (part) == SET 351 && SET_DEST (part) == hard_frame_pointer_rtx) 352 RTX_FRAME_RELATED_P (part) = 0; 353 else 354 RTX_FRAME_RELATED_P (part) = 1; 355 } 356 } 357 } 358 else 359 { 360 insn = emit_insn (gen_movsi_push (frame_pointer_rtx)); 361 RTX_FRAME_RELATED_P (insn) = 1; 362 363 if (frame_pointer_needed) 364 { 365 insn = emit_insn (gen_movsi (frame_pointer_rtx, stack_pointer_rtx)); 366 RTX_FRAME_RELATED_P (insn) = 1; 367 } 368 } 369 } 370 371 /* Allocate the stack frame. */ 372 if (current_frame_info.frame_size == 0) 373 ; /* Nothing to do. */ 374 else if (current_frame_info.save_fp 375 && current_frame_info.frame_size < ((1 << 10) - UNITS_PER_WORD)) 376 ; /* Nothing to do. */ 377 else if (current_frame_info.frame_size <= 512) 378 { 379 insn = emit_insn (gen_add_to_stack 380 (GEN_INT (- (signed) current_frame_info.frame_size))); 381 RTX_FRAME_RELATED_P (insn) = 1; 382 } 383 else 384 { 385 rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM); 386 insn = emit_insn (gen_movsi (tmp, GEN_INT (current_frame_info.frame_size))); 387 RTX_FRAME_RELATED_P (insn) = 1; 388 insn = emit_insn (gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp)); 389 RTX_FRAME_RELATED_P (insn) = 1; 390 } 391 392 if (crtl->profile) 393 emit_insn (gen_blockage ()); 394 } 395 396 /* Called after register allocation to add any instructions needed for the 397 epilogue. Using an epilogue insn is favored compared to putting all of the 398 instructions in output_function_epilogue(), since it allows the scheduler 399 to intermix instructions with the restores of the caller saved registers. 400 In some cases, it might be necessary to emit a barrier instruction as the 401 first insn to prevent such scheduling. */ 402 void 403 fr30_expand_epilogue (void) 404 { 405 int regno; 406 407 /* Perform the inversion operations of the prologue. */ 408 gcc_assert (current_frame_info.initialised); 409 410 /* Pop local variables and arguments off the stack. 411 If frame_pointer_needed is TRUE then the frame pointer register 412 has actually been used as a frame pointer, and we can recover 413 the stack pointer from it, otherwise we must unwind the stack 414 manually. */ 415 if (current_frame_info.frame_size > 0) 416 { 417 if (current_frame_info.save_fp && frame_pointer_needed) 418 { 419 emit_insn (gen_leave_func ()); 420 current_frame_info.save_fp = 0; 421 } 422 else if (current_frame_info.frame_size <= 508) 423 emit_insn (gen_add_to_stack 424 (GEN_INT (current_frame_info.frame_size))); 425 else 426 { 427 rtx tmp = gen_rtx_REG (Pmode, PROLOGUE_TMP_REGNUM); 428 emit_insn (gen_movsi (tmp, GEN_INT (current_frame_info.frame_size))); 429 emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, tmp)); 430 } 431 } 432 433 if (current_frame_info.save_fp) 434 emit_insn (gen_movsi_pop (frame_pointer_rtx)); 435 436 /* Pop all the registers that were pushed. */ 437 if (current_frame_info.save_rp) 438 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode, RETURN_POINTER_REGNUM))); 439 440 for (regno = 0; regno < STACK_POINTER_REGNUM; regno ++) 441 if (current_frame_info.gmask & (1 << regno)) 442 emit_insn (gen_movsi_pop (gen_rtx_REG (Pmode, regno))); 443 444 if (current_frame_info.pretend_size) 445 emit_insn (gen_add_to_stack (GEN_INT (current_frame_info.pretend_size))); 446 447 /* Reset state info for each function. */ 448 current_frame_info = zero_frame_info; 449 450 emit_jump_insn (gen_return_from_func ()); 451 } 452 453 /* Do any needed setup for a variadic function. We must create a register 454 parameter block, and then copy any anonymous arguments, plus the last 455 named argument, from registers into memory. * copying actually done in 456 fr30_expand_prologue(). 457 458 ARG_REGS_USED_SO_FAR has *not* been updated for the last named argument 459 which has type TYPE and mode MODE, and we rely on this fact. */ 460 void 461 fr30_setup_incoming_varargs (cumulative_args_t arg_regs_used_so_far_v, 462 machine_mode mode, 463 tree type ATTRIBUTE_UNUSED, 464 int *pretend_size, 465 int second_time ATTRIBUTE_UNUSED) 466 { 467 CUMULATIVE_ARGS *arg_regs_used_so_far 468 = get_cumulative_args (arg_regs_used_so_far_v); 469 int size; 470 471 /* All BLKmode values are passed by reference. */ 472 gcc_assert (mode != BLKmode); 473 474 /* ??? This run-time test as well as the code inside the if 475 statement is probably unnecessary. */ 476 if (targetm.calls.strict_argument_naming (arg_regs_used_so_far_v)) 477 /* If TARGET_STRICT_ARGUMENT_NAMING returns true, then the last named 478 arg must not be treated as an anonymous arg. */ 479 /* ??? This is a pointer increment, which makes no sense. */ 480 arg_regs_used_so_far += fr30_num_arg_regs (mode, type); 481 482 size = FR30_NUM_ARG_REGS - (* arg_regs_used_so_far); 483 484 if (size <= 0) 485 return; 486 487 * pretend_size = (size * UNITS_PER_WORD); 488 } 489 490 /*}}}*/ 491 /*{{{ Printing operands */ 492 493 /* Print a memory address as an operand to reference that memory location. */ 494 495 void 496 fr30_print_operand_address (FILE *stream, rtx address) 497 { 498 switch (GET_CODE (address)) 499 { 500 case SYMBOL_REF: 501 output_addr_const (stream, address); 502 break; 503 504 default: 505 fprintf (stderr, "code = %x\n", GET_CODE (address)); 506 debug_rtx (address); 507 output_operand_lossage ("fr30_print_operand_address: unhandled address"); 508 break; 509 } 510 } 511 512 /* Print an operand. */ 513 514 void 515 fr30_print_operand (FILE *file, rtx x, int code) 516 { 517 rtx x0; 518 519 switch (code) 520 { 521 case '#': 522 /* Output a :D if this instruction is delayed. */ 523 if (dbr_sequence_length () != 0) 524 fputs (":D", file); 525 return; 526 527 case 'p': 528 /* Compute the register name of the second register in a hi/lo 529 register pair. */ 530 if (GET_CODE (x) != REG) 531 output_operand_lossage ("fr30_print_operand: unrecognized %%p code"); 532 else 533 fprintf (file, "r%d", REGNO (x) + 1); 534 return; 535 536 case 'b': 537 /* Convert GCC's comparison operators into FR30 comparison codes. */ 538 switch (GET_CODE (x)) 539 { 540 case EQ: fprintf (file, "eq"); break; 541 case NE: fprintf (file, "ne"); break; 542 case LT: fprintf (file, "lt"); break; 543 case LE: fprintf (file, "le"); break; 544 case GT: fprintf (file, "gt"); break; 545 case GE: fprintf (file, "ge"); break; 546 case LTU: fprintf (file, "c"); break; 547 case LEU: fprintf (file, "ls"); break; 548 case GTU: fprintf (file, "hi"); break; 549 case GEU: fprintf (file, "nc"); break; 550 default: 551 output_operand_lossage ("fr30_print_operand: unrecognized %%b code"); 552 break; 553 } 554 return; 555 556 case 'B': 557 /* Convert GCC's comparison operators into the complimentary FR30 558 comparison codes. */ 559 switch (GET_CODE (x)) 560 { 561 case EQ: fprintf (file, "ne"); break; 562 case NE: fprintf (file, "eq"); break; 563 case LT: fprintf (file, "ge"); break; 564 case LE: fprintf (file, "gt"); break; 565 case GT: fprintf (file, "le"); break; 566 case GE: fprintf (file, "lt"); break; 567 case LTU: fprintf (file, "nc"); break; 568 case LEU: fprintf (file, "hi"); break; 569 case GTU: fprintf (file, "ls"); break; 570 case GEU: fprintf (file, "c"); break; 571 default: 572 output_operand_lossage ("fr30_print_operand: unrecognized %%B code"); 573 break; 574 } 575 return; 576 577 case 'A': 578 /* Print a signed byte value as an unsigned value. */ 579 if (GET_CODE (x) != CONST_INT) 580 output_operand_lossage ("fr30_print_operand: invalid operand to %%A code"); 581 else 582 { 583 HOST_WIDE_INT val; 584 585 val = INTVAL (x); 586 587 val &= 0xff; 588 589 fprintf (file, HOST_WIDE_INT_PRINT_DEC, val); 590 } 591 return; 592 593 case 'x': 594 if (GET_CODE (x) != CONST_INT 595 || INTVAL (x) < 16 596 || INTVAL (x) > 32) 597 output_operand_lossage ("fr30_print_operand: invalid %%x code"); 598 else 599 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) - 16); 600 return; 601 602 case 'F': 603 if (GET_CODE (x) != CONST_DOUBLE) 604 output_operand_lossage ("fr30_print_operand: invalid %%F code"); 605 else 606 { 607 char str[30]; 608 609 real_to_decimal (str, CONST_DOUBLE_REAL_VALUE (x), 610 sizeof (str), 0, 1); 611 fputs (str, file); 612 } 613 return; 614 615 case 0: 616 /* Handled below. */ 617 break; 618 619 default: 620 fprintf (stderr, "unknown code = %x\n", code); 621 output_operand_lossage ("fr30_print_operand: unknown code"); 622 return; 623 } 624 625 switch (GET_CODE (x)) 626 { 627 case REG: 628 fputs (reg_names [REGNO (x)], file); 629 break; 630 631 case MEM: 632 x0 = XEXP (x,0); 633 634 switch (GET_CODE (x0)) 635 { 636 case REG: 637 gcc_assert ((unsigned) REGNO (x0) < ARRAY_SIZE (reg_names)); 638 fprintf (file, "@%s", reg_names [REGNO (x0)]); 639 break; 640 641 case PLUS: 642 if (GET_CODE (XEXP (x0, 0)) != REG 643 || REGNO (XEXP (x0, 0)) < FRAME_POINTER_REGNUM 644 || REGNO (XEXP (x0, 0)) > STACK_POINTER_REGNUM 645 || GET_CODE (XEXP (x0, 1)) != CONST_INT) 646 { 647 fprintf (stderr, "bad INDEXed address:"); 648 debug_rtx (x); 649 output_operand_lossage ("fr30_print_operand: unhandled MEM"); 650 } 651 else if (REGNO (XEXP (x0, 0)) == FRAME_POINTER_REGNUM) 652 { 653 HOST_WIDE_INT val = INTVAL (XEXP (x0, 1)); 654 if (val < -(1 << 9) || val > ((1 << 9) - 4)) 655 { 656 fprintf (stderr, "frame INDEX out of range:"); 657 debug_rtx (x); 658 output_operand_lossage ("fr30_print_operand: unhandled MEM"); 659 } 660 fprintf (file, "@(r14, #" HOST_WIDE_INT_PRINT_DEC ")", val); 661 } 662 else 663 { 664 HOST_WIDE_INT val = INTVAL (XEXP (x0, 1)); 665 if (val < 0 || val > ((1 << 6) - 4)) 666 { 667 fprintf (stderr, "stack INDEX out of range:"); 668 debug_rtx (x); 669 output_operand_lossage ("fr30_print_operand: unhandled MEM"); 670 } 671 fprintf (file, "@(r15, #" HOST_WIDE_INT_PRINT_DEC ")", val); 672 } 673 break; 674 675 case SYMBOL_REF: 676 output_address (VOIDmode, x0); 677 break; 678 679 default: 680 fprintf (stderr, "bad MEM code = %x\n", GET_CODE (x0)); 681 debug_rtx (x); 682 output_operand_lossage ("fr30_print_operand: unhandled MEM"); 683 break; 684 } 685 break; 686 687 case CONST_DOUBLE : 688 /* We handle SFmode constants here as output_addr_const doesn't. */ 689 if (GET_MODE (x) == SFmode) 690 { 691 long l; 692 693 REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), l); 694 fprintf (file, "0x%08lx", l); 695 break; 696 } 697 698 /* FALLTHRU */ 699 /* Let output_addr_const deal with it. */ 700 default: 701 output_addr_const (file, x); 702 break; 703 } 704 705 return; 706 } 707 708 /*}}}*/ 709 710 /* Implements TARGET_FUNCTION_VALUE. */ 711 712 static rtx 713 fr30_function_value (const_tree valtype, 714 const_tree fntype_or_decli ATTRIBUTE_UNUSED, 715 bool outgoing ATTRIBUTE_UNUSED) 716 { 717 return gen_rtx_REG (TYPE_MODE (valtype), RETURN_VALUE_REGNUM); 718 } 719 720 /* Implements TARGET_LIBCALL_VALUE. */ 721 722 static rtx 723 fr30_libcall_value (machine_mode mode, 724 const_rtx fun ATTRIBUTE_UNUSED) 725 { 726 return gen_rtx_REG (mode, RETURN_VALUE_REGNUM); 727 } 728 729 /* Implements TARGET_FUNCTION_VALUE_REGNO_P. */ 730 731 static bool 732 fr30_function_value_regno_p (const unsigned int regno) 733 { 734 return (regno == RETURN_VALUE_REGNUM); 735 } 736 737 /*{{{ Function arguments */ 738 739 /* Return true if we should pass an argument on the stack rather than 740 in registers. */ 741 742 static bool 743 fr30_must_pass_in_stack (machine_mode mode, const_tree type) 744 { 745 if (mode == BLKmode) 746 return true; 747 if (type == NULL) 748 return false; 749 return AGGREGATE_TYPE_P (type); 750 } 751 752 /* Compute the number of word sized registers needed to hold a 753 function argument of mode INT_MODE and tree type TYPE. */ 754 static int 755 fr30_num_arg_regs (machine_mode mode, const_tree type) 756 { 757 int size; 758 759 if (targetm.calls.must_pass_in_stack (mode, type)) 760 return 0; 761 762 if (type && mode == BLKmode) 763 size = int_size_in_bytes (type); 764 else 765 size = GET_MODE_SIZE (mode); 766 767 return (size + UNITS_PER_WORD - 1) / UNITS_PER_WORD; 768 } 769 770 /* Returns the number of bytes in which *part* of a parameter of machine 771 mode MODE and tree type TYPE (which may be NULL if the type is not known). 772 If the argument fits entirely in the argument registers, or entirely on 773 the stack, then 0 is returned. 774 CUM is the number of argument registers already used by earlier 775 parameters to the function. */ 776 777 static int 778 fr30_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode, 779 tree type, bool named) 780 { 781 CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); 782 783 /* Unnamed arguments, i.e. those that are prototyped as ... 784 are always passed on the stack. 785 Also check here to see if all the argument registers are full. */ 786 if (named == 0 || *cum >= FR30_NUM_ARG_REGS) 787 return 0; 788 789 /* Work out how many argument registers would be needed if this 790 parameter were to be passed entirely in registers. If there 791 are sufficient argument registers available (or if no registers 792 are needed because the parameter must be passed on the stack) 793 then return zero, as this parameter does not require partial 794 register, partial stack stack space. */ 795 if (*cum + fr30_num_arg_regs (mode, type) <= FR30_NUM_ARG_REGS) 796 return 0; 797 798 return (FR30_NUM_ARG_REGS - *cum) * UNITS_PER_WORD; 799 } 800 801 static rtx 802 fr30_function_arg (cumulative_args_t cum_v, machine_mode mode, 803 const_tree type, bool named) 804 { 805 CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v); 806 807 if (!named 808 || fr30_must_pass_in_stack (mode, type) 809 || *cum >= FR30_NUM_ARG_REGS) 810 return NULL_RTX; 811 else 812 return gen_rtx_REG (mode, *cum + FIRST_ARG_REGNUM); 813 } 814 815 /* A C statement (sans semicolon) to update the summarizer variable CUM to 816 advance past an argument in the argument list. The values MODE, TYPE and 817 NAMED describe that argument. Once this is done, the variable CUM is 818 suitable for analyzing the *following* argument with `FUNCTION_ARG', etc. 819 820 This macro need not do anything if the argument in question was passed on 821 the stack. The compiler knows how to track the amount of stack space used 822 for arguments without any special help. */ 823 static void 824 fr30_function_arg_advance (cumulative_args_t cum, machine_mode mode, 825 const_tree type, bool named) 826 { 827 *get_cumulative_args (cum) += named * fr30_num_arg_regs (mode, type); 828 } 829 830 /*}}}*/ 831 /*{{{ Operand predicates */ 832 833 #ifndef Mmode 834 #define Mmode machine_mode 835 #endif 836 837 /* Returns true iff all the registers in the operands array 838 are in descending or ascending order. */ 839 int 840 fr30_check_multiple_regs (rtx *operands, int num_operands, int descending) 841 { 842 if (descending) 843 { 844 unsigned int prev_regno = 0; 845 846 while (num_operands --) 847 { 848 if (GET_CODE (operands [num_operands]) != REG) 849 return 0; 850 851 if (REGNO (operands [num_operands]) < prev_regno) 852 return 0; 853 854 prev_regno = REGNO (operands [num_operands]); 855 } 856 } 857 else 858 { 859 unsigned int prev_regno = CONDITION_CODE_REGNUM; 860 861 while (num_operands --) 862 { 863 if (GET_CODE (operands [num_operands]) != REG) 864 return 0; 865 866 if (REGNO (operands [num_operands]) > prev_regno) 867 return 0; 868 869 prev_regno = REGNO (operands [num_operands]); 870 } 871 } 872 873 return 1; 874 } 875 876 int 877 fr30_const_double_is_zero (rtx operand) 878 { 879 if (operand == NULL || GET_CODE (operand) != CONST_DOUBLE) 880 return 0; 881 882 return real_equal (CONST_DOUBLE_REAL_VALUE (operand), &dconst0); 883 } 884 885 /*}}}*/ 886 /*{{{ Instruction Output Routines */ 887 888 /* Output a double word move. 889 It must be REG<-REG, REG<-MEM, MEM<-REG or REG<-CONST. 890 On the FR30 we are constrained by the fact that it does not 891 support offsetable addresses, and so we have to load the 892 address of the secnd word into the second destination register 893 before we can use it. */ 894 895 rtx 896 fr30_move_double (rtx * operands) 897 { 898 rtx src = operands[1]; 899 rtx dest = operands[0]; 900 enum rtx_code src_code = GET_CODE (src); 901 enum rtx_code dest_code = GET_CODE (dest); 902 machine_mode mode = GET_MODE (dest); 903 rtx val; 904 905 start_sequence (); 906 907 if (dest_code == REG) 908 { 909 if (src_code == REG) 910 { 911 int reverse = (REGNO (dest) == REGNO (src) + 1); 912 913 /* We normally copy the low-numbered register first. However, if 914 the first register of operand 0 is the same as the second register 915 of operand 1, we must copy in the opposite order. */ 916 emit_insn (gen_rtx_SET (operand_subword (dest, reverse, TRUE, mode), 917 operand_subword (src, reverse, TRUE, mode))); 918 919 emit_insn 920 (gen_rtx_SET (operand_subword (dest, !reverse, TRUE, mode), 921 operand_subword (src, !reverse, TRUE, mode))); 922 } 923 else if (src_code == MEM) 924 { 925 rtx addr = XEXP (src, 0); 926 rtx dest0 = operand_subword (dest, 0, TRUE, mode); 927 rtx dest1 = operand_subword (dest, 1, TRUE, mode); 928 rtx new_mem; 929 930 gcc_assert (GET_CODE (addr) == REG); 931 932 /* Copy the address before clobbering it. See PR 34174. */ 933 emit_insn (gen_rtx_SET (dest1, addr)); 934 emit_insn (gen_rtx_SET (dest0, adjust_address (src, SImode, 0))); 935 emit_insn (gen_rtx_SET (dest1, plus_constant (SImode, dest1, 936 UNITS_PER_WORD))); 937 938 new_mem = gen_rtx_MEM (SImode, dest1); 939 MEM_COPY_ATTRIBUTES (new_mem, src); 940 941 emit_insn (gen_rtx_SET (dest1, new_mem)); 942 } 943 else if (src_code == CONST_INT || src_code == CONST_DOUBLE) 944 { 945 rtx words[2]; 946 split_double (src, &words[0], &words[1]); 947 emit_insn (gen_rtx_SET (operand_subword (dest, 0, TRUE, mode), 948 words[0])); 949 950 emit_insn (gen_rtx_SET (operand_subword (dest, 1, TRUE, mode), 951 words[1])); 952 } 953 } 954 else if (src_code == REG && dest_code == MEM) 955 { 956 rtx addr = XEXP (dest, 0); 957 rtx src0; 958 rtx src1; 959 960 gcc_assert (GET_CODE (addr) == REG); 961 962 src0 = operand_subword (src, 0, TRUE, mode); 963 src1 = operand_subword (src, 1, TRUE, mode); 964 965 emit_move_insn (adjust_address (dest, SImode, 0), src0); 966 967 if (REGNO (addr) == STACK_POINTER_REGNUM 968 || REGNO (addr) == FRAME_POINTER_REGNUM) 969 emit_insn (gen_rtx_SET (adjust_address (dest, SImode, UNITS_PER_WORD), 970 src1)); 971 else 972 { 973 rtx new_mem; 974 rtx scratch_reg_r0 = gen_rtx_REG (SImode, 0); 975 976 /* We need a scratch register to hold the value of 'address + 4'. 977 We use r0 for this purpose. It is used for example for long 978 jumps and is already marked to not be used by normal register 979 allocation. */ 980 emit_insn (gen_movsi_internal (scratch_reg_r0, addr)); 981 emit_insn (gen_addsi_small_int (scratch_reg_r0, scratch_reg_r0, 982 GEN_INT (UNITS_PER_WORD))); 983 new_mem = gen_rtx_MEM (SImode, scratch_reg_r0); 984 MEM_COPY_ATTRIBUTES (new_mem, dest); 985 emit_move_insn (new_mem, src1); 986 emit_insn (gen_blockage ()); 987 } 988 } 989 else 990 /* This should have been prevented by the constraints on movdi_insn. */ 991 gcc_unreachable (); 992 993 val = get_insns (); 994 end_sequence (); 995 996 return val; 997 } 998 999 /* Implement TARGET_FRAME_POINTER_REQUIRED. */ 1000 1001 bool 1002 fr30_frame_pointer_required (void) 1003 { 1004 return (flag_omit_frame_pointer == 0 || crtl->args.pretend_args_size > 0); 1005 } 1006 1007 /*}}}*/ 1008 /*{{{ Trampoline Output Routines */ 1009 1010 /* Implement TARGET_ASM_TRAMPOLINE_TEMPLATE. 1011 On the FR30, the trampoline is: 1012 1013 nop 1014 ldi:32 STATIC, r12 1015 nop 1016 ldi:32 FUNCTION, r0 1017 jmp @r0 1018 1019 The no-ops are to guarantee that the static chain and final 1020 target are 32 bit aligned within the trampoline. That allows us to 1021 initialize those locations with simple SImode stores. The alternative 1022 would be to use HImode stores. */ 1023 1024 static void 1025 fr30_asm_trampoline_template (FILE *f) 1026 { 1027 fprintf (f, "\tnop\n"); 1028 fprintf (f, "\tldi:32\t#0, %s\n", reg_names [STATIC_CHAIN_REGNUM]); 1029 fprintf (f, "\tnop\n"); 1030 fprintf (f, "\tldi:32\t#0, %s\n", reg_names [COMPILER_SCRATCH_REGISTER]); 1031 fprintf (f, "\tjmp\t@%s\n", reg_names [COMPILER_SCRATCH_REGISTER]); 1032 } 1033 1034 /* Implement TARGET_TRAMPOLINE_INIT. */ 1035 1036 static void 1037 fr30_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value) 1038 { 1039 rtx fnaddr = XEXP (DECL_RTL (fndecl), 0); 1040 rtx mem; 1041 1042 emit_block_move (m_tramp, assemble_trampoline_template (), 1043 GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL); 1044 1045 mem = adjust_address (m_tramp, SImode, 4); 1046 emit_move_insn (mem, chain_value); 1047 mem = adjust_address (m_tramp, SImode, 12); 1048 emit_move_insn (mem, fnaddr); 1049 } 1050 1051 /*}}}*/ 1052 /* Local Variables: */ 1053 /* folded-file: t */ 1054 /* End: */ 1055