gcc/config/ft32/ft32.c

   1 /* Target Code for ft32
   2    Copyright (C) 2015  Free Software Foundation
   3    Contributed by FTDI <support@ftdi.com>
   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 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "backend.h"
  25 #include "cfghooks.h"
  26 #include "tree.h"
  27 #include "rtl.h"
  28 #include "df.h"
  29 #include "regs.h"
  30 #include "insn-config.h"
  31 #include "conditions.h"
  32 #include "insn-flags.h"
  33 #include "output.h"
  34 #include "insn-attr.h"
  35 #include "flags.h"
  36 #include "recog.h"
  37 #include "reload.h"
  38 #include "diagnostic-core.h"
  39 #include "alias.h"
  40 #include "stor-layout.h"
  41 #include "calls.h"
  42 #include "expr.h"
  43 #include "optabs.h"
  44 #include "except.h"
  45 #include "target.h"
  46 #include "tm_p.h"
  47 #include "langhooks.h"
  48 #include "cfgrtl.h"
  49 #include "cfganal.h"
  50 #include "lcm.h"
  51 #include "cfgbuild.h"
  52 #include "cfgcleanup.h"
  53 #include "builtins.h"
  54 #include "emit-rtl.h"
  55
  56 /* This file should be included last.  */
  57 #include "target-def.h"
  58
  59 #include <stdint.h>
  60
  61 #define LOSE_AND_RETURN(msgid, x)               \
  62   do                                            \
  63     {                                           \
  64       ft32_operand_lossage (msgid, x);            \
  65       return;                                   \
  66     } while (0)
  67
  68 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
  69
  70 static bool
  71 ft32_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
  72 {
  73   const HOST_WIDE_INT size = int_size_in_bytes (type);
  74   return (size == -1 || size > 2 * UNITS_PER_WORD);
  75 }
  76
  77 /* Define how to find the value returned by a function.
  78    VALTYPE is the data type of the value (as a tree).
  79    If the precise function being called is known, FUNC is its
  80    FUNCTION_DECL; otherwise, FUNC is 0.
  81
  82    We always return values in register $r0 for ft32.  */
  83
  84 static rtx
  85 ft32_function_value (const_tree valtype,
  86                      const_tree fntype_or_decl ATTRIBUTE_UNUSED,
  87                      bool outgoing ATTRIBUTE_UNUSED)
  88 {
  89   return gen_rtx_REG (TYPE_MODE (valtype), FT32_R0);
  90 }
  91
  92 /* Define how to find the value returned by a library function.
  93
  94    We always return values in register $r0 for ft32.  */
  95
  96 static rtx
  97 ft32_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
  98 {
  99   return gen_rtx_REG (mode, FT32_R0);
 100 }
 101
 102 /* Handle TARGET_FUNCTION_VALUE_REGNO_P.
 103
 104    We always return values in register $r0 for ft32.  */
 105
 106 static bool
 107 ft32_function_value_regno_p (const unsigned int regno)
 108 {
 109   return (regno == FT32_R0);
 110 }
 111
 112 /* Emit an error message when we're in an asm, and a fatal error for
 113    "normal" insns.  Formatted output isn't easily implemented, since we
 114    use output_operand_lossage to output the actual message and handle the
 115    categorization of the error.  */
 116
 117 static void
 118 ft32_operand_lossage (const char *msgid, rtx op)
 119 {
 120   debug_rtx (op);
 121   output_operand_lossage ("%s", msgid);
 122 }
 123
 124 /* The PRINT_OPERAND_ADDRESS worker.  */
 125
 126 void
 127 ft32_print_operand_address (FILE * file, rtx x)
 128 {
 129   switch (GET_CODE (x))
 130     {
 131     case REG:
 132       fprintf (file, "%s,0", reg_names[REGNO (x)]);
 133       break;
 134
 135     case PLUS:
 136       switch (GET_CODE (XEXP (x, 1)))
 137         {
 138         case CONST_INT:
 139           fprintf (file, "%s,%ld",
 140                    reg_names[REGNO (XEXP (x, 0))], INTVAL (XEXP (x, 1)));
 141           break;
 142         case SYMBOL_REF:
 143           output_addr_const (file, XEXP (x, 1));
 144           fprintf (file, "(%s)", reg_names[REGNO (XEXP (x, 0))]);
 145           break;
 146         case CONST:
 147           {
 148             rtx plus = XEXP (XEXP (x, 1), 0);
 149             if (GET_CODE (XEXP (plus, 0)) == SYMBOL_REF
 150                 && CONST_INT_P (XEXP (plus, 1)))
 151               {
 152                 output_addr_const (file, XEXP (plus, 0));
 153                 fprintf (file, "+%ld(%s)", INTVAL (XEXP (plus, 1)),
 154                          reg_names[REGNO (XEXP (x, 0))]);
 155               }
 156             else
 157               abort ();
 158           }
 159           break;
 160         default:
 161           abort ();
 162         }
 163       break;
 164
 165     default:
 166       output_addr_const (file, x);
 167       break;
 168     }
 169 }
 170
 171 /* The PRINT_OPERAND worker.  */
 172
 173 void
 174 ft32_print_operand (FILE * file, rtx x, int code)
 175 {
 176   rtx operand = x;
 177
 178   /* New code entries should just be added to the switch below.  If
 179      handling is finished, just return.  If handling was just a
 180      modification of the operand, the modified operand should be put in
 181      "operand", and then do a break to let default handling
 182      (zero-modifier) output the operand.  */
 183
 184   switch (code)
 185     {
 186     case 0:
 187       /* No code, print as usual.  */
 188       break;
 189
 190     case 'h':
 191       if (GET_CODE (operand) != REG)
 192         internal_error ("'h' applied to non-register operand");
 193       fprintf (file, "%s", reg_names[REGNO (operand) + 1]);
 194       return;
 195
 196     case 'm':
 197       fprintf (file, "%ld", (long) (- INTVAL(x)));
 198       return;
 199
 200     case 'd':                   // a DW spec, from an integer alignment (for BLKmode insns)
 201       {
 202         int i = INTVAL (x);
 203         char dwspec;
 204         switch (i)
 205           {
 206           case 1:
 207             dwspec = 'b';
 208             break;
 209           case 2:
 210             dwspec = 's';
 211             break;
 212           case 4:
 213             dwspec = 'l';
 214             break;
 215           default:
 216             if ((i % 4) != 0)
 217               internal_error ("bad alignment: %d", i);
 218             else
 219               dwspec = 'l';
 220             break;
 221           }
 222         fprintf (file, "%c", dwspec);
 223         return;
 224       }
 225
 226     case 'f':
 227       {
 228         int bf = ft32_as_bitfield (INTVAL (x));
 229         fprintf (file, "512|(%d<<5)|%d", bf >> 5, bf & 31);
 230         return;
 231       }
 232
 233     case 'g':
 234       {
 235         int bf = ft32_as_bitfield (0xffffffff ^ INTVAL (x));
 236         fprintf (file, "(%d<<5)|%d", bf >> 5, bf & 31);
 237         return;
 238       }
 239
 240     case 'b':
 241       {
 242         ft32_print_operand (file, XEXP (x, 0), 0);
 243         return;
 244       }
 245
 246     default:
 247       LOSE_AND_RETURN ("invalid operand modifier letter", x);
 248     }
 249
 250   /* Print an operand as without a modifier letter.  */
 251   switch (GET_CODE (operand))
 252     {
 253     case REG:
 254       fprintf (file, "%s", reg_names[REGNO (operand)]);
 255       return;
 256
 257     case MEM:
 258       output_address (XEXP (operand, 0));
 259       return;
 260
 261     default:
 262       /* No need to handle all strange variants, let output_addr_const
 263          do it for us.  */
 264       if (CONSTANT_P (operand))
 265         {
 266           output_addr_const (file, operand);
 267           return;
 268         }
 269
 270       LOSE_AND_RETURN ("unexpected operand", x);
 271     }
 272 }
 273
 274 const char *
 275 ft32_load_immediate (rtx dst, int32_t i)
 276 {
 277   char pattern[100];
 278
 279   if ((-524288 <= i) && (i <= 524287))
 280     {
 281       sprintf (pattern, "ldk.l  %%0,%d", i);
 282       output_asm_insn (pattern, &dst);
 283     }
 284   else if ((-536870912 <= i) && (i <= 536870911))
 285     {
 286       ft32_load_immediate (dst, i >> 10);
 287       sprintf (pattern, "ldl.l  %%0,%%0,%d", i & 1023);
 288       output_asm_insn (pattern, &dst);
 289     }
 290   else
 291     {
 292       int rd;                   // rotate distance
 293       uint32_t u = i;
 294       for (rd = 1; rd < 32; rd++)
 295         {
 296           u = ((u >> 31) & 1) | (u << 1);
 297           if ((-524288 <= (int32_t) u) && ((int32_t) u <= 524287))
 298             {
 299               ft32_load_immediate (dst, (int32_t) u);
 300               sprintf (pattern, "ror.l  %%0,%%0,%d", rd);
 301               output_asm_insn (pattern, &dst);
 302               return "";
 303             }
 304         }
 305       ft32_load_immediate (dst, i >> 10);
 306       sprintf (pattern, "ldl.l  %%0,%%0,%d", i & 1023);
 307       output_asm_insn (pattern, &dst);
 308     }
 309
 310   return "";
 311 }
 312
 313 // x is a bit mask, for example:
 314 //    00000000000000000000001111111110
 315 // If x contains a single bit mask, return the bitfield spec.
 316 // in the above case it returns ((9 << 5) | 1)
 317 // Otherwise return -1.
 318 //
 319
 320 #define NBITS(n)  ((1U << (n)) - 1U)
 321
 322 int
 323 ft32_as_bitfield (unsigned int x)
 324 {
 325   int lobit, hibit;
 326
 327   if (x == 0)
 328     return -1;
 329
 330   for (lobit = 0; lobit < 32; lobit++)
 331     if (x & (1 << lobit))
 332       break;
 333   for (hibit = 31; hibit >= 0; hibit--)
 334     if (x & (1 << hibit))
 335       break;
 336
 337   int width = 1 + hibit - lobit;
 338   if (width > 16)
 339     return -1;
 340
 341   if (x != (NBITS (width) << lobit))
 342     return -1;                  // not a clean bitfield
 343
 344   return ((width & 15) << 5) | lobit;
 345 }
 346
 347 /* Per-function machine data.  */
 348 struct GTY (()) machine_function
 349 {
 350   /* Number of bytes saved on the stack for callee saved registers.  */
 351   int callee_saved_reg_size;
 352
 353   /* Number of bytes saved on the stack for local variables.  */
 354   int local_vars_size;
 355
 356   /* The sum of 2 sizes: locals vars and padding byte for saving the
 357    * registers.  Used in expand_prologue () and expand_epilogue ().  */
 358   int size_for_adjusting_sp;
 359 };
 360
 361 /* Zero initialization is OK for all current fields.  */
 362
 363 static struct machine_function *
 364 ft32_init_machine_status (void)
 365 {
 366   return ggc_cleared_alloc < machine_function > ();
 367 }
 368
 369
 370 /* The TARGET_OPTION_OVERRIDE worker.
 371    All this curently does is set init_machine_status.  */
 372 static void
 373 ft32_option_override (void)
 374 {
 375   /* Set the per-function-data initializer.  */
 376   init_machine_status = ft32_init_machine_status;
 377 }
 378
 379 /* Implement targetm.select_section.  */
 380 static section *
 381 ft32_select_section (tree decl, int reloc, unsigned HOST_WIDE_INT align)
 382 {
 383   /* Variables and constants defined in the __ea address space
 384      go into a special section named "._ea".  */
 385   if (TREE_TYPE (decl) != error_mark_node
 386       && TYPE_ADDR_SPACE (TREE_TYPE (decl)) == ADDR_SPACE_PM)
 387     {
 388       /* We might get called with string constants, but get_named_section
 389          doesn't like them as they are not DECLs.  Also, we need to set
 390          flags in that case.  */
 391       if (!DECL_P (decl))
 392         return get_section ("._pm", SECTION_WRITE | SECTION_DEBUG, NULL);
 393
 394       return get_named_section (decl, "._pm", reloc);
 395     }
 396
 397   return default_elf_select_section (decl, reloc, align);
 398 }
 399
 400 /* Compute the size of the local area and the size to be adjusted by the
 401  * prologue and epilogue.  */
 402
 403 static void
 404 ft32_compute_frame (void)
 405 {
 406   /* For aligning the local variables.  */
 407   int stack_alignment = STACK_BOUNDARY / BITS_PER_UNIT;
 408   int padding_locals;
 409   int regno;
 410
 411   /* Padding needed for each element of the frame.  */
 412   cfun->machine->local_vars_size = get_frame_size ();
 413
 414   /* Align to the stack alignment.  */
 415   padding_locals = cfun->machine->local_vars_size % stack_alignment;
 416   if (padding_locals)
 417     padding_locals = stack_alignment - padding_locals;
 418
 419   cfun->machine->local_vars_size += padding_locals;
 420
 421   cfun->machine->callee_saved_reg_size = 0;
 422
 423   /* Save callee-saved registers.  */
 424   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 425     if (df_regs_ever_live_p (regno) && (!call_used_regs[regno]))
 426       cfun->machine->callee_saved_reg_size += 4;
 427
 428   cfun->machine->size_for_adjusting_sp =
 429     crtl->args.pretend_args_size
 430     + cfun->machine->local_vars_size
 431     + (ACCUMULATE_OUTGOING_ARGS ? crtl->outgoing_args_size : 0);
 432 }
 433
 434 // Must use LINK/UNLINK when...
 435 // the frame is bigger than 512 bytes so cannot just "SUB" from SP
 436 // the function actually uses $fp
 437
 438 static int
 439 must_link (void)
 440 {
 441   int bigframe = (cfun->machine->size_for_adjusting_sp >= 512);
 442   return (bigframe || frame_pointer_needed || df_regs_ever_live_p (FT32_FP)
 443           || df_regs_ever_live_p (FT32_FP));
 444 }
 445
 446 void
 447 ft32_expand_prologue (void)
 448 {
 449   int regno;
 450   rtx insn;
 451
 452   ft32_compute_frame ();
 453
 454   if (flag_stack_usage_info)
 455     current_function_static_stack_size = cfun->machine->size_for_adjusting_sp;
 456
 457   if (!must_link () && (cfun->machine->callee_saved_reg_size == 4))
 458     {
 459       insn =
 460         emit_insn (gen_link
 461                    (gen_rtx_REG (Pmode, FT32_R13),
 462                     GEN_INT (-cfun->machine->size_for_adjusting_sp)));
 463       RTX_FRAME_RELATED_P (insn) = 1;
 464       return;
 465     }
 466   /* Save callee-saved registers.  */
 467   if (optimize_size)
 468     {
 469       for (regno = FIRST_PSEUDO_REGISTER; regno-- > 0;)
 470         {
 471           if (!fixed_regs[regno] && !call_used_regs[regno]
 472               && df_regs_ever_live_p (regno))
 473             {
 474               rtx preg = gen_rtx_REG (Pmode, regno);
 475               emit_insn (gen_call_prolog (preg));
 476               break;
 477             }
 478         }
 479     }
 480   else
 481     {
 482       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 483         {
 484           if (!fixed_regs[regno] && df_regs_ever_live_p (regno)
 485               && !call_used_regs[regno])
 486             {
 487               insn = emit_insn (gen_movsi_push (gen_rtx_REG (Pmode, regno)));
 488               RTX_FRAME_RELATED_P (insn) = 1;
 489             }
 490         }
 491     }
 492
 493   if (65536 <= cfun->machine->size_for_adjusting_sp)
 494     {
 495       error ("stack frame must be smaller than 64K");
 496       return;
 497     }
 498   if (must_link ())
 499     {
 500       insn =
 501         emit_insn (gen_link
 502                    (gen_rtx_REG (Pmode, FT32_FP),
 503                     GEN_INT (-cfun->machine->size_for_adjusting_sp)));
 504       RTX_FRAME_RELATED_P (insn) = 1;
 505     }
 506   else if (cfun->machine->size_for_adjusting_sp > 0)
 507     {
 508       insn = emit_insn (gen_addsi3 (gen_rtx_REG (SImode, FT32_SP),
 509                                     gen_rtx_REG (SImode, FT32_SP),
 510                                     GEN_INT (-(cfun->machine->
 511                                                size_for_adjusting_sp))));
 512       RTX_FRAME_RELATED_P (insn) = 1;
 513     }
 514 }
 515
 516 void
 517 ft32_expand_epilogue (void)
 518 {
 519   int regno;
 520
 521   if (!must_link ()
 522       && (cfun->machine->size_for_adjusting_sp == 24)
 523       && (cfun->machine->callee_saved_reg_size == 0))
 524     {
 525       emit_jump_insn (gen_returner24 ());
 526       return;
 527     }
 528
 529   // Set when the epilog code will also add 24 to $sp
 530   int epilog24 = (!must_link ()
 531                   && (cfun->machine->size_for_adjusting_sp == 24)
 532                   && optimize_size);
 533
 534   if (must_link ())
 535     {
 536       emit_insn (gen_unlink ());
 537     }
 538   else if (!epilog24 && (cfun->machine->size_for_adjusting_sp > 0))
 539     {
 540       emit_insn (gen_addsi3 (gen_rtx_REG (SImode, FT32_SP),
 541                              gen_rtx_REG (SImode, FT32_SP),
 542                              GEN_INT (cfun->machine->size_for_adjusting_sp)));
 543     }
 544
 545   if (cfun->machine->callee_saved_reg_size != 0)
 546     {
 547       for (regno = FIRST_PSEUDO_REGISTER; regno-- > 0;)
 548         {
 549           if (!fixed_regs[regno] && !call_used_regs[regno]
 550               && df_regs_ever_live_p (regno))
 551             {
 552               rtx preg = gen_rtx_REG (Pmode, regno);
 553               if (optimize_size)
 554                 {
 555                   if (epilog24)
 556                     emit_insn (gen_jump_epilog24 (preg));
 557                   else
 558                     emit_insn (gen_jump_epilog (preg));
 559                   return;
 560                 }
 561               emit_insn (gen_movsi_pop (preg));
 562             }
 563         }
 564     }
 565
 566   emit_jump_insn (gen_returner ());
 567 }
 568
 569 #undef TARGET_FRAME_POINTER_REQUIRED
 570 #define TARGET_FRAME_POINTER_REQUIRED ft32_frame_pointer_required
 571 static bool
 572 ft32_frame_pointer_required (void)
 573 {
 574   return cfun->calls_alloca;
 575 }
 576
 577 #undef  TARGET_CAN_ELIMINATE
 578 #define TARGET_CAN_ELIMINATE ft32_can_eliminate
 579
 580 /* Return true if register FROM can be eliminated via register TO.  */
 581
 582 static bool
 583 ft32_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
 584 {
 585   return 1;
 586   return (to == FRAME_POINTER_REGNUM) || !ft32_frame_pointer_required ();
 587 }
 588
 589 /* Implements the macro INITIAL_ELIMINATION_OFFSET, return the OFFSET.  */
 590
 591 int
 592 ft32_initial_elimination_offset (int from, int to)
 593 {
 594   ft32_compute_frame ();
 595
 596   if (from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM)
 597     {
 598       return cfun->machine->callee_saved_reg_size + 2 * UNITS_PER_WORD;
 599     }
 600
 601   if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
 602     {
 603       int arg_offset;
 604       arg_offset = must_link ()? 2 : 1;
 605       return ((cfun->machine->callee_saved_reg_size
 606                + arg_offset * UNITS_PER_WORD)
 607               + cfun->machine->size_for_adjusting_sp);
 608     }
 609
 610   if ((from == FRAME_POINTER_REGNUM) && (to == STACK_POINTER_REGNUM))
 611     {
 612       return cfun->machine->size_for_adjusting_sp;
 613     }
 614
 615   gcc_unreachable ();
 616 }
 617
 618 /* Worker function for TARGET_SETUP_INCOMING_VARARGS.  */
 619
 620 static void
 621 ft32_setup_incoming_varargs (cumulative_args_t cum_v,
 622                              enum machine_mode mode ATTRIBUTE_UNUSED,
 623                              tree type ATTRIBUTE_UNUSED,
 624                              int *pretend_size, int no_rtl)
 625 {
 626   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 627   int regno;
 628   int regs = 8 - *cum;
 629
 630   *pretend_size = regs < 0 ? 0 : GET_MODE_SIZE (SImode) * regs;
 631
 632   if (no_rtl)
 633     return;
 634
 635   for (regno = *cum; regno < 8; regno++)
 636     {
 637       rtx reg = gen_rtx_REG (SImode, regno);
 638       rtx slot = gen_rtx_PLUS (Pmode,
 639                                gen_rtx_REG (SImode, ARG_POINTER_REGNUM),
 640                                GEN_INT (UNITS_PER_WORD * (regno - FT32_R0)));
 641
 642       emit_move_insn (gen_rtx_MEM (SImode, slot), reg);
 643     }
 644 }
 645
 646
 647 /* Return the fixed registers used for condition codes.  */
 648
 649 static bool
 650 ft32_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
 651 {
 652   *p1 = CC_REG;
 653   *p2 = INVALID_REGNUM;
 654   return true;
 655 }
 656
 657 /* Return the next register to be used to hold a function argument or
 658    NULL_RTX if there's no more space.  */
 659
 660 static rtx
 661 ft32_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
 662                    const_tree type ATTRIBUTE_UNUSED,
 663                    bool named ATTRIBUTE_UNUSED)
 664 {
 665   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 666
 667   if (*cum < 8)
 668     return gen_rtx_REG (mode, *cum);
 669   else
 670     return NULL_RTX;
 671 }
 672
 673 #define FT32_FUNCTION_ARG_SIZE(MODE, TYPE)      \
 674   ((MODE) != BLKmode ? GET_MODE_SIZE (MODE)     \
 675    : (unsigned) int_size_in_bytes (TYPE))
 676
 677 static void
 678 ft32_function_arg_advance (cumulative_args_t cum_v, enum machine_mode mode,
 679                            const_tree type, bool named ATTRIBUTE_UNUSED)
 680 {
 681   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 682
 683   *cum = (*cum < FT32_R6
 684           ? *cum + ((3 + FT32_FUNCTION_ARG_SIZE (mode, type)) / 4) : *cum);
 685 }
 686
 687 /* Return non-zero if the function argument described by TYPE is to be
 688    passed by reference.  */
 689
 690 static bool
 691 ft32_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
 692                         enum machine_mode mode, const_tree type,
 693                         bool named ATTRIBUTE_UNUSED)
 694 {
 695   unsigned HOST_WIDE_INT size;
 696
 697   if (type)
 698     {
 699       if (AGGREGATE_TYPE_P (type))
 700         return true;
 701       size = int_size_in_bytes (type);
 702     }
 703   else
 704     size = GET_MODE_SIZE (mode);
 705
 706   return size > 4 * 6;
 707 }
 708
 709 /* Some function arguments will only partially fit in the registers
 710    that hold arguments.  Given a new arg, return the number of bytes
 711    that fit in argument passing registers.  */
 712
 713 static int
 714 ft32_arg_partial_bytes (cumulative_args_t cum_v,
 715                         enum machine_mode mode, tree type, bool named)
 716 {
 717   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 718   int bytes_left, size;
 719
 720   if (*cum >= 8)
 721     return 0;
 722
 723   if (ft32_pass_by_reference (cum_v, mode, type, named))
 724     size = 4;
 725   else if (type)
 726     {
 727       if (AGGREGATE_TYPE_P (type))
 728         return 0;
 729       size = int_size_in_bytes (type);
 730     }
 731   else
 732     size = GET_MODE_SIZE (mode);
 733
 734   bytes_left = (4 * 6) - ((*cum - 2) * 4);
 735
 736   if (size > bytes_left)
 737     return bytes_left;
 738   else
 739     return 0;
 740 }
 741
 742 /* Used by constraints.md to distinguish between GENERIC and PM
 743    memory addresses.  */
 744
 745 int
 746 ft32_is_mem_pm (rtx o)
 747 {
 748   return (MEM_P (o)
 749           && !ADDR_SPACE_GENERIC_P (MEM_ADDR_SPACE (o)));
 750 }
 751
 752 /* The Global `targetm' Variable.  */
 753
 754 /* Initialize the GCC target structure.  */
 755
 756 #undef  TARGET_PROMOTE_PROTOTYPES
 757 #define TARGET_PROMOTE_PROTOTYPES       hook_bool_const_tree_true
 758
 759 #undef  TARGET_RETURN_IN_MEMORY
 760 #define TARGET_RETURN_IN_MEMORY         ft32_return_in_memory
 761 #undef  TARGET_MUST_PASS_IN_STACK
 762 #define TARGET_MUST_PASS_IN_STACK       must_pass_in_stack_var_size
 763 #undef  TARGET_PASS_BY_REFERENCE
 764 #define TARGET_PASS_BY_REFERENCE        ft32_pass_by_reference
 765 #undef  TARGET_ARG_PARTIAL_BYTES
 766 #define TARGET_ARG_PARTIAL_BYTES        ft32_arg_partial_bytes
 767 #undef  TARGET_FUNCTION_ARG
 768 #define TARGET_FUNCTION_ARG             ft32_function_arg
 769 #undef  TARGET_FUNCTION_ARG_ADVANCE
 770 #define TARGET_FUNCTION_ARG_ADVANCE     ft32_function_arg_advance
 771
 772
 773 #undef  TARGET_SETUP_INCOMING_VARARGS
 774 #define TARGET_SETUP_INCOMING_VARARGS   ft32_setup_incoming_varargs
 775
 776 #undef  TARGET_FIXED_CONDITION_CODE_REGS
 777 #define TARGET_FIXED_CONDITION_CODE_REGS ft32_fixed_condition_code_regs
 778
 779 /* Define this to return an RTX representing the place where a
 780    function returns or receives a value of data type RET_TYPE, a tree
 781    node representing a data type.  */
 782 #undef TARGET_FUNCTION_VALUE
 783 #define TARGET_FUNCTION_VALUE ft32_function_value
 784 #undef TARGET_LIBCALL_VALUE
 785 #define TARGET_LIBCALL_VALUE ft32_libcall_value
 786 #undef TARGET_FUNCTION_VALUE_REGNO_P
 787 #define TARGET_FUNCTION_VALUE_REGNO_P ft32_function_value_regno_p
 788
 789 #undef TARGET_OPTION_OVERRIDE
 790 #define TARGET_OPTION_OVERRIDE ft32_option_override
 791
 792 #undef TARGET_ASM_SELECT_SECTION
 793 #define TARGET_ASM_SELECT_SECTION  ft32_select_section
 794
 795 #undef TARGET_VALID_POINTER_MODE
 796 #define TARGET_VALID_POINTER_MODE ft32_valid_pointer_mode
 797 static bool
 798 ft32_valid_pointer_mode (enum machine_mode mode)
 799 {
 800   if (mode == SImode)
 801     return 1;
 802   return 0;
 803 }
 804
 805 #undef TARGET_ADDR_SPACE_POINTER_MODE
 806 #define TARGET_ADDR_SPACE_POINTER_MODE ft32_addr_space_pointer_mode
 807 static enum machine_mode
 808 ft32_addr_space_pointer_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
 809 {
 810   return Pmode;
 811 }
 812
 813 #undef TARGET_ADDR_SPACE_ADDRESS_MODE
 814 #define TARGET_ADDR_SPACE_ADDRESS_MODE ft32_addr_space_address_mode
 815 static enum machine_mode
 816 ft32_addr_space_address_mode (addr_space_t addrspace ATTRIBUTE_UNUSED)
 817 {
 818   return Pmode;
 819 }
 820
 821 #undef TARGET_ADDR_SPACE_SUBSET_P
 822 #define TARGET_ADDR_SPACE_SUBSET_P ft32_addr_space_subset_p
 823 static bool
 824 ft32_addr_space_subset_p (addr_space_t subset ATTRIBUTE_UNUSED,
 825                           addr_space_t superset ATTRIBUTE_UNUSED)
 826 {
 827   return false;
 828 }
 829
 830 #undef TARGET_CASE_VALUES_THRESHOLD
 831 #define TARGET_CASE_VALUES_THRESHOLD ft32_target_case_values_threshold
 832
 833 static unsigned int
 834 ft32_target_case_values_threshold (void)
 835 {
 836   return 4;
 837 }
 838
 839 #undef TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
 840 #define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P \
 841   ft32_addr_space_legitimate_address_p
 842
 843
 844 // Enabling LRA gives the infamous
 845 //    internal compiler error: Max. number of generated reload insns per insn is achieved (90)
 846 // errors e.g. when compiling sieve.c
 847
 848 static bool
 849 ft32_lra_p (void)
 850 {
 851   return ft32_lra_flag;
 852 }
 853
 854 #undef TARGET_LRA_P
 855 #define TARGET_LRA_P ft32_lra_p
 856
 857 static bool
 858 reg_ok_for_base_p (rtx r, bool strict)
 859 {
 860   int NUM = REGNO (r);
 861   if (strict)
 862     return (HARD_REGNO_OK_FOR_BASE_P (NUM)
 863             || HARD_REGNO_OK_FOR_BASE_P (reg_renumber[(NUM)]));
 864   else
 865     return ((NUM) >= FIRST_PSEUDO_REGISTER || HARD_REGNO_OK_FOR_BASE_P (NUM));
 866 }
 867
 868 static bool
 869 ft32_addr_space_legitimate_address_p (enum machine_mode mode, rtx x,
 870                                       bool strict,
 871                                       addr_space_t as ATTRIBUTE_UNUSED)
 872 {
 873   if (mode != BLKmode)
 874     {
 875       if (GET_CODE (x) == PLUS)
 876         {
 877           rtx op1, op2;
 878           op1 = XEXP (x, 0);
 879           op2 = XEXP (x, 1);
 880           if (GET_CODE (op1) == REG
 881               && CONST_INT_P (op2)
 882               && INTVAL (op2) >= -128
 883               && INTVAL (op2) < 128 && reg_ok_for_base_p (op1, strict))
 884             goto yes;
 885           if (GET_CODE (op1) == SYMBOL_REF && CONST_INT_P (op2))
 886             goto yes;
 887         }
 888       if (REG_P (x) && reg_ok_for_base_p (x, strict))
 889         goto yes;
 890       if (GET_CODE (x) == SYMBOL_REF
 891           || GET_CODE (x) == LABEL_REF || CONST_INT_P (x))
 892         goto yes;
 893     }
 894   else
 895     {
 896       if (REG_P (x) && reg_ok_for_base_p (x, strict))
 897         goto yes;
 898     }
 899
 900   return 0;
 901 yes:
 902   return 1;
 903 }
 904
 905 struct gcc_target targetm = TARGET_INITIALIZER;
 906
 907 #include "gt-ft32.h"