gcc/config/v850/v850.c

   1 /* Subroutines for insn-output.c for NEC V850 series
   2    Copyright (C) 1996-2018 Free Software Foundation, Inc.
   3    Contributed by Jeff Law (law@cygnus.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 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, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15    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 #define IN_TARGET_CODE 1
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "backend.h"
  27 #include "target.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "df.h"
  31 #include "memmodel.h"
  32 #include "tm_p.h"
  33 #include "stringpool.h"
  34 #include "attribs.h"
  35 #include "insn-config.h"
  36 #include "regs.h"
  37 #include "emit-rtl.h"
  38 #include "recog.h"
  39 #include "diagnostic-core.h"
  40 #include "stor-layout.h"
  41 #include "varasm.h"
  42 #include "calls.h"
  43 #include "conditions.h"
  44 #include "output.h"
  45 #include "insn-attr.h"
  46 #include "expr.h"
  47 #include "cfgrtl.h"
  48 #include "builtins.h"
  49
  50 /* This file should be included last.  */
  51 #include "target-def.h"
  52
  53 #ifndef streq
  54 #define streq(a,b) (strcmp (a, b) == 0)
  55 #endif
  56
  57 static void v850_print_operand_address (FILE *, machine_mode, rtx);
  58
  59 /* Names of the various data areas used on the v850.  */
  60 const char * GHS_default_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
  61 const char * GHS_current_section_names [(int) COUNT_OF_GHS_SECTION_KINDS];
  62
  63 /* Track the current data area set by the data area pragma (which
  64    can be nested).  Tested by check_default_data_area.  */
  65 data_area_stack_element * data_area_stack = NULL;
  66
  67 /* True if we don't need to check any more if the current
  68    function is an interrupt handler.  */
  69 static int v850_interrupt_cache_p = FALSE;
  70
  71 /* Whether current function is an interrupt handler.  */
  72 static int v850_interrupt_p = FALSE;
  73
  74 static GTY(()) section * rosdata_section;
  75 static GTY(()) section * rozdata_section;
  76 static GTY(()) section * tdata_section;
  77 static GTY(()) section * zdata_section;
  78 static GTY(()) section * zbss_section;
  79 \f
  80 /* We use this to wrap all emitted insns in the prologue.  */
  81 static rtx
  82 F (rtx x)
  83 {
  84   if (GET_CODE (x) != CLOBBER)
  85     RTX_FRAME_RELATED_P (x) = 1;
  86   return x;
  87 }
  88
  89 /* Mark all the subexpressions of the PARALLEL rtx PAR as
  90    frame-related.  Return PAR.
  91
  92    dwarf2out.c:dwarf2out_frame_debug_expr ignores sub-expressions of a
  93    PARALLEL rtx other than the first if they do not have the
  94    FRAME_RELATED flag set on them.  */
  95
  96 static rtx
  97 v850_all_frame_related (rtx par)
  98 {
  99   int len = XVECLEN (par, 0);
 100   int i;
 101
 102   gcc_assert (GET_CODE (par) == PARALLEL);
 103   for (i = 0; i < len; i++)
 104     F (XVECEXP (par, 0, i));
 105
 106   return par;
 107 }
 108
 109 /* Handle the TARGET_PASS_BY_REFERENCE target hook.
 110    Specify whether to pass the argument by reference.  */
 111
 112 static bool
 113 v850_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
 114                         machine_mode mode, const_tree type,
 115                         bool named ATTRIBUTE_UNUSED)
 116 {
 117   unsigned HOST_WIDE_INT size;
 118
 119   if (!TARGET_GCC_ABI)
 120     return 0;
 121
 122   if (type)
 123     size = int_size_in_bytes (type);
 124   else
 125     size = GET_MODE_SIZE (mode);
 126
 127   return size > 8;
 128 }
 129
 130 /* Return an RTX to represent where an argument with mode MODE
 131    and type TYPE will be passed to a function.  If the result
 132    is NULL_RTX, the argument will be pushed.  */
 133
 134 static rtx
 135 v850_function_arg (cumulative_args_t cum_v, machine_mode mode,
 136                    const_tree type, bool named)
 137 {
 138   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 139   rtx result = NULL_RTX;
 140   int size, align;
 141
 142   if (!named)
 143     return NULL_RTX;
 144
 145   if (mode == BLKmode)
 146     size = int_size_in_bytes (type);
 147   else
 148     size = GET_MODE_SIZE (mode);
 149
 150   size = (size + UNITS_PER_WORD -1) & ~(UNITS_PER_WORD -1);
 151
 152   if (size < 1)
 153     {
 154       /* Once we have stopped using argument registers, do not start up again.  */
 155       cum->nbytes = 4 * UNITS_PER_WORD;
 156       return NULL_RTX;
 157     }
 158
 159   if (!TARGET_GCC_ABI)
 160     align = UNITS_PER_WORD;
 161   else if (size <= UNITS_PER_WORD && type)
 162     align = TYPE_ALIGN (type) / BITS_PER_UNIT;
 163   else
 164     align = size;
 165
 166   cum->nbytes = (cum->nbytes + align - 1) &~(align - 1);
 167
 168   if (cum->nbytes > 4 * UNITS_PER_WORD)
 169     return NULL_RTX;
 170
 171   if (type == NULL_TREE
 172       && cum->nbytes + size > 4 * UNITS_PER_WORD)
 173     return NULL_RTX;
 174
 175   switch (cum->nbytes / UNITS_PER_WORD)
 176     {
 177     case 0:
 178       result = gen_rtx_REG (mode, 6);
 179       break;
 180     case 1:
 181       result = gen_rtx_REG (mode, 7);
 182       break;
 183     case 2:
 184       result = gen_rtx_REG (mode, 8);
 185       break;
 186     case 3:
 187       result = gen_rtx_REG (mode, 9);
 188       break;
 189     default:
 190       result = NULL_RTX;
 191     }
 192
 193   return result;
 194 }
 195
 196 /* Return the number of bytes which must be put into registers
 197    for values which are part in registers and part in memory.  */
 198 static int
 199 v850_arg_partial_bytes (cumulative_args_t cum_v, machine_mode mode,
 200                         tree type, bool named)
 201 {
 202   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 203   int size, align;
 204
 205   if (!named)
 206     return 0;
 207
 208   if (mode == BLKmode)
 209     size = int_size_in_bytes (type);
 210   else
 211     size = GET_MODE_SIZE (mode);
 212
 213   if (size < 1)
 214     size = 1;
 215
 216   if (!TARGET_GCC_ABI)
 217     align = UNITS_PER_WORD;
 218   else if (type)
 219     align = TYPE_ALIGN (type) / BITS_PER_UNIT;
 220   else
 221     align = size;
 222
 223   cum->nbytes = (cum->nbytes + align - 1) & ~ (align - 1);
 224
 225   if (cum->nbytes > 4 * UNITS_PER_WORD)
 226     return 0;
 227
 228   if (cum->nbytes + size <= 4 * UNITS_PER_WORD)
 229     return 0;
 230
 231   if (type == NULL_TREE
 232       && cum->nbytes + size > 4 * UNITS_PER_WORD)
 233     return 0;
 234
 235   return 4 * UNITS_PER_WORD - cum->nbytes;
 236 }
 237
 238 /* Update the data in CUM to advance over an argument
 239    of mode MODE and data type TYPE.
 240    (TYPE is null for libcalls where that information may not be available.)  */
 241
 242 static void
 243 v850_function_arg_advance (cumulative_args_t cum_v, machine_mode mode,
 244                            const_tree type, bool named ATTRIBUTE_UNUSED)
 245 {
 246   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
 247
 248   if (!TARGET_GCC_ABI)
 249     cum->nbytes += (((mode != BLKmode
 250                       ? GET_MODE_SIZE (mode)
 251                       : int_size_in_bytes (type)) + UNITS_PER_WORD - 1)
 252                     & -UNITS_PER_WORD);
 253   else
 254     cum->nbytes += (((type && int_size_in_bytes (type) > 8
 255                       ? GET_MODE_SIZE (Pmode)
 256                       : (mode != BLKmode
 257                          ? GET_MODE_SIZE (mode)
 258                          : int_size_in_bytes (type))) + UNITS_PER_WORD - 1)
 259                     & -UNITS_PER_WORD);
 260 }
 261
 262 /* Return the high and low words of a CONST_DOUBLE */
 263
 264 static void
 265 const_double_split (rtx x, HOST_WIDE_INT * p_high, HOST_WIDE_INT * p_low)
 266 {
 267   if (GET_CODE (x) == CONST_DOUBLE)
 268     {
 269       long t[2];
 270
 271       switch (GET_MODE (x))
 272         {
 273         case E_DFmode:
 274           REAL_VALUE_TO_TARGET_DOUBLE (*CONST_DOUBLE_REAL_VALUE (x), t);
 275           *p_high = t[1];       /* since v850 is little endian */
 276           *p_low = t[0];        /* high is second word */
 277           return;
 278
 279         case E_SFmode:
 280           REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (x), *p_high);
 281           *p_low = 0;
 282           return;
 283
 284         case E_VOIDmode:
 285         case E_DImode:
 286           *p_high = CONST_DOUBLE_HIGH (x);
 287           *p_low  = CONST_DOUBLE_LOW (x);
 288           return;
 289
 290         default:
 291           break;
 292         }
 293     }
 294
 295   fatal_insn ("const_double_split got a bad insn:", x);
 296 }
 297
 298 \f
 299 /* Return the cost of the rtx R with code CODE.  */
 300
 301 static int
 302 const_costs_int (HOST_WIDE_INT value, int zero_cost)
 303 {
 304   if (CONST_OK_FOR_I (value))
 305       return zero_cost;
 306   else if (CONST_OK_FOR_J (value))
 307     return 1;
 308   else if (CONST_OK_FOR_K (value))
 309     return 2;
 310   else
 311     return 4;
 312 }
 313
 314 static int
 315 const_costs (rtx r, enum rtx_code c)
 316 {
 317   HOST_WIDE_INT high, low;
 318
 319   switch (c)
 320     {
 321     case CONST_INT:
 322       return const_costs_int (INTVAL (r), 0);
 323
 324     case CONST_DOUBLE:
 325       const_double_split (r, &high, &low);
 326       if (GET_MODE (r) == SFmode)
 327         return const_costs_int (high, 1);
 328       else
 329         return const_costs_int (high, 1) + const_costs_int (low, 1);
 330
 331     case SYMBOL_REF:
 332     case LABEL_REF:
 333     case CONST:
 334       return 2;
 335
 336     case HIGH:
 337       return 1;
 338
 339     default:
 340       return 4;
 341     }
 342 }
 343
 344 static bool
 345 v850_rtx_costs (rtx x, machine_mode mode, int outer_code,
 346                 int opno ATTRIBUTE_UNUSED, int *total, bool speed)
 347 {
 348   enum rtx_code code = GET_CODE (x);
 349
 350   switch (code)
 351     {
 352     case CONST_INT:
 353     case CONST_DOUBLE:
 354     case CONST:
 355     case SYMBOL_REF:
 356     case LABEL_REF:
 357       *total = COSTS_N_INSNS (const_costs (x, code));
 358       return true;
 359
 360     case MOD:
 361     case DIV:
 362     case UMOD:
 363     case UDIV:
 364       if (TARGET_V850E && !speed)
 365         *total = 6;
 366       else
 367         *total = 60;
 368       return true;
 369
 370     case MULT:
 371       if (TARGET_V850E
 372           && (mode == SImode || mode == HImode || mode == QImode))
 373         {
 374           if (GET_CODE (XEXP (x, 1)) == REG)
 375             *total = 4;
 376           else if (GET_CODE (XEXP (x, 1)) == CONST_INT)
 377             {
 378               if (CONST_OK_FOR_O (INTVAL (XEXP (x, 1))))
 379                 *total = 6;
 380               else if (CONST_OK_FOR_K (INTVAL (XEXP (x, 1))))
 381                 *total = 10;
 382             }
 383         }
 384       else
 385         *total = 20;
 386       return true;
 387
 388     case ZERO_EXTRACT:
 389       if (outer_code == COMPARE)
 390         *total = 0;
 391       return false;
 392
 393     default:
 394       return false;
 395     }
 396 }
 397 \f
 398 /* Print operand X using operand code CODE to assembly language output file
 399    FILE.  */
 400
 401 static void
 402 v850_print_operand (FILE * file, rtx x, int code)
 403 {
 404   HOST_WIDE_INT high, low;
 405
 406   switch (code)
 407     {
 408     case 'c':
 409       /* We use 'c' operands with symbols for .vtinherit.  */
 410       if (GET_CODE (x) == SYMBOL_REF)
 411         {
 412           output_addr_const(file, x);
 413           break;
 414         }
 415       /* Fall through.  */
 416     case 'b':
 417     case 'B':
 418     case 'C':
 419     case 'd':
 420     case 'D':
 421       switch ((code == 'B' || code == 'C' || code == 'D')
 422               ? reverse_condition (GET_CODE (x)) : GET_CODE (x))
 423         {
 424           case NE:
 425             if (code == 'c' || code == 'C')
 426               fprintf (file, "nz");
 427             else
 428               fprintf (file, "ne");
 429             break;
 430           case EQ:
 431             if (code == 'c' || code == 'C')
 432               fprintf (file, "z");
 433             else
 434               fprintf (file, "e");
 435             break;
 436           case GE:
 437             if (code == 'D' || code == 'd')
 438               fprintf (file, "p");
 439             else
 440               fprintf (file, "ge");
 441             break;
 442           case GT:
 443             fprintf (file, "gt");
 444             break;
 445           case LE:
 446             fprintf (file, "le");
 447             break;
 448           case LT:
 449             if (code == 'D' || code == 'd')
 450               fprintf (file, "n");
 451             else
 452               fprintf (file, "lt");
 453             break;
 454           case GEU:
 455             fprintf (file, "nl");
 456             break;
 457           case GTU:
 458             fprintf (file, "h");
 459             break;
 460           case LEU:
 461             fprintf (file, "nh");
 462             break;
 463           case LTU:
 464             fprintf (file, "l");
 465             break;
 466           default:
 467             gcc_unreachable ();
 468         }
 469       break;
 470     case 'F':                   /* High word of CONST_DOUBLE.  */
 471       switch (GET_CODE (x))
 472         {
 473         case CONST_INT:
 474           fprintf (file, "%d", (INTVAL (x) >= 0) ? 0 : -1);
 475           break;
 476
 477         case CONST_DOUBLE:
 478           const_double_split (x, &high, &low);
 479           fprintf (file, "%ld", (long) high);
 480           break;
 481
 482         default:
 483           gcc_unreachable ();
 484         }
 485       break;
 486     case 'G':                   /* Low word of CONST_DOUBLE.  */
 487       switch (GET_CODE (x))
 488         {
 489         case CONST_INT:
 490           fprintf (file, "%ld", (long) INTVAL (x));
 491           break;
 492
 493         case CONST_DOUBLE:
 494           const_double_split (x, &high, &low);
 495           fprintf (file, "%ld", (long) low);
 496           break;
 497
 498         default:
 499           gcc_unreachable ();
 500         }
 501       break;
 502     case 'L':
 503       fprintf (file, "%d\n", (int)(INTVAL (x) & 0xffff));
 504       break;
 505     case 'M':
 506       fprintf (file, "%d", exact_log2 (INTVAL (x)));
 507       break;
 508     case 'O':
 509       gcc_assert (special_symbolref_operand (x, VOIDmode));
 510
 511       if (GET_CODE (x) == CONST)
 512         x = XEXP (XEXP (x, 0), 0);
 513       else
 514         gcc_assert (GET_CODE (x) == SYMBOL_REF);
 515
 516       if (SYMBOL_REF_ZDA_P (x))
 517         fprintf (file, "zdaoff");
 518       else if (SYMBOL_REF_SDA_P (x))
 519         fprintf (file, "sdaoff");
 520       else if (SYMBOL_REF_TDA_P (x))
 521         fprintf (file, "tdaoff");
 522       else
 523         gcc_unreachable ();
 524       break;
 525     case 'P':
 526       gcc_assert (special_symbolref_operand (x, VOIDmode));
 527       output_addr_const (file, x);
 528       break;
 529     case 'Q':
 530       gcc_assert (special_symbolref_operand (x, VOIDmode));
 531
 532       if (GET_CODE (x) == CONST)
 533         x = XEXP (XEXP (x, 0), 0);
 534       else
 535         gcc_assert (GET_CODE (x) == SYMBOL_REF);
 536
 537       if (SYMBOL_REF_ZDA_P (x))
 538         fprintf (file, "r0");
 539       else if (SYMBOL_REF_SDA_P (x))
 540         fprintf (file, "gp");
 541       else if (SYMBOL_REF_TDA_P (x))
 542         fprintf (file, "ep");
 543       else
 544         gcc_unreachable ();
 545       break;
 546     case 'R':           /* 2nd word of a double.  */
 547       switch (GET_CODE (x))
 548         {
 549         case REG:
 550           fprintf (file, reg_names[REGNO (x) + 1]);
 551           break;
 552         case MEM:
 553           {
 554             machine_mode mode = GET_MODE (x);
 555             x = XEXP (adjust_address (x, SImode, 4), 0);
 556             v850_print_operand_address (file, mode, x);
 557             if (GET_CODE (x) == CONST_INT)
 558               fprintf (file, "[r0]");
 559           }
 560           break;
 561
 562         case CONST_INT:
 563           {
 564             unsigned HOST_WIDE_INT v = INTVAL (x);
 565
 566             /* Trickery to avoid problems with shifting
 567                32-bits at a time on a 32-bit host.  */
 568             v = v >> 16;
 569             v = v >> 16;
 570             fprintf (file, HOST_WIDE_INT_PRINT_HEX, v);
 571             break;
 572           }
 573
 574         case CONST_DOUBLE:
 575           fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_HIGH (x));
 576           break;
 577
 578         default:
 579           debug_rtx (x);
 580           gcc_unreachable ();
 581         }
 582       break;
 583     case 'S':
 584       {
 585         /* If it's a reference to a TDA variable, use sst/sld vs. st/ld.  */
 586         if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), FALSE))
 587           fputs ("s", file);
 588
 589         break;
 590       }
 591     case 'T':
 592       {
 593         /* Like an 'S' operand above, but for unsigned loads only.  */
 594         if (GET_CODE (x) == MEM && ep_memory_operand (x, GET_MODE (x), TRUE))
 595           fputs ("s", file);
 596
 597         break;
 598       }
 599     case 'W':                   /* Print the instruction suffix.  */
 600       switch (GET_MODE (x))
 601         {
 602         default:
 603           gcc_unreachable ();
 604
 605         case E_QImode: fputs (".b", file); break;
 606         case E_HImode: fputs (".h", file); break;
 607         case E_SImode: fputs (".w", file); break;
 608         case E_SFmode: fputs (".w", file); break;
 609         }
 610       break;
 611     case '.':                   /* Register r0.  */
 612       fputs (reg_names[0], file);
 613       break;
 614     case 'z':                   /* Reg or zero.  */
 615       if (REG_P (x))
 616         fputs (reg_names[REGNO (x)], file);
 617       else if ((GET_MODE(x) == SImode
 618                 || GET_MODE(x) == DFmode
 619                 || GET_MODE(x) == SFmode)
 620                 && x == CONST0_RTX(GET_MODE(x)))
 621       fputs (reg_names[0], file);
 622       else
 623         {
 624           gcc_assert (x == const0_rtx);
 625           fputs (reg_names[0], file);
 626         }
 627       break;
 628     default:
 629       switch (GET_CODE (x))
 630         {
 631         case MEM:
 632           if (GET_CODE (XEXP (x, 0)) == CONST_INT)
 633             output_address (GET_MODE (x),
 634                             gen_rtx_PLUS (SImode, gen_rtx_REG (SImode, 0),
 635                                           XEXP (x, 0)));
 636           else
 637             output_address (GET_MODE (x), XEXP (x, 0));
 638           break;
 639
 640         case REG:
 641           fputs (reg_names[REGNO (x)], file);
 642           break;
 643         case SUBREG:
 644           fputs (reg_names[subreg_regno (x)], file);
 645           break;
 646         case CONST_DOUBLE:
 647           fprintf (file, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
 648           break;
 649
 650         case CONST_INT:
 651         case SYMBOL_REF:
 652         case CONST:
 653         case LABEL_REF:
 654         case CODE_LABEL:
 655           v850_print_operand_address (file, VOIDmode, x);
 656           break;
 657         default:
 658           gcc_unreachable ();
 659         }
 660       break;
 661
 662     }
 663 }
 664
 665 \f
 666 /* Output assembly language output for the address ADDR to FILE.  */
 667
 668 static void
 669 v850_print_operand_address (FILE * file, machine_mode /*mode*/, rtx addr)
 670 {
 671   switch (GET_CODE (addr))
 672     {
 673     case REG:
 674       fprintf (file, "0[");
 675       v850_print_operand (file, addr, 0);
 676       fprintf (file, "]");
 677       break;
 678     case LO_SUM:
 679       if (GET_CODE (XEXP (addr, 0)) == REG)
 680         {
 681           /* reg,foo */
 682           fprintf (file, "lo(");
 683           v850_print_operand (file, XEXP (addr, 1), 0);
 684           fprintf (file, ")[");
 685           v850_print_operand (file, XEXP (addr, 0), 0);
 686           fprintf (file, "]");
 687         }
 688       break;
 689     case PLUS:
 690       if (GET_CODE (XEXP (addr, 0)) == REG
 691           || GET_CODE (XEXP (addr, 0)) == SUBREG)
 692         {
 693           /* reg,foo */
 694           v850_print_operand (file, XEXP (addr, 1), 0);
 695           fprintf (file, "[");
 696           v850_print_operand (file, XEXP (addr, 0), 0);
 697           fprintf (file, "]");
 698         }
 699       else
 700         {
 701           v850_print_operand (file, XEXP (addr, 0), 0);
 702           fprintf (file, "+");
 703           v850_print_operand (file, XEXP (addr, 1), 0);
 704         }
 705       break;
 706     case SYMBOL_REF:
 707       {
 708         const char *off_name = NULL;
 709         const char *reg_name = NULL;
 710
 711         if (SYMBOL_REF_ZDA_P (addr))
 712           {
 713             off_name = "zdaoff";
 714             reg_name = "r0";
 715           }
 716         else if (SYMBOL_REF_SDA_P (addr))
 717           {
 718             off_name = "sdaoff";
 719             reg_name = "gp";
 720           }
 721         else if (SYMBOL_REF_TDA_P (addr))
 722           {
 723             off_name = "tdaoff";
 724             reg_name = "ep";
 725           }
 726
 727         if (off_name)
 728           fprintf (file, "%s(", off_name);
 729         output_addr_const (file, addr);
 730         if (reg_name)
 731           fprintf (file, ")[%s]", reg_name);
 732       }
 733       break;
 734     case CONST:
 735       if (special_symbolref_operand (addr, VOIDmode))
 736         {
 737           rtx x = XEXP (XEXP (addr, 0), 0);
 738           const char *off_name;
 739           const char *reg_name;
 740
 741           if (SYMBOL_REF_ZDA_P (x))
 742             {
 743               off_name = "zdaoff";
 744               reg_name = "r0";
 745             }
 746           else if (SYMBOL_REF_SDA_P (x))
 747             {
 748               off_name = "sdaoff";
 749               reg_name = "gp";
 750             }
 751           else if (SYMBOL_REF_TDA_P (x))
 752             {
 753               off_name = "tdaoff";
 754               reg_name = "ep";
 755             }
 756           else
 757             gcc_unreachable ();
 758
 759           fprintf (file, "%s(", off_name);
 760           output_addr_const (file, addr);
 761           fprintf (file, ")[%s]", reg_name);
 762         }
 763       else
 764         output_addr_const (file, addr);
 765       break;
 766     default:
 767       output_addr_const (file, addr);
 768       break;
 769     }
 770 }
 771
 772 static bool
 773 v850_print_operand_punct_valid_p (unsigned char code)
 774 {
 775   return code == '.';
 776 }
 777
 778 /* When assemble_integer is used to emit the offsets for a switch
 779    table it can encounter (TRUNCATE:HI (MINUS:SI (LABEL_REF:SI) (LABEL_REF:SI))).
 780    output_addr_const will normally barf at this, but it is OK to omit
 781    the truncate and just emit the difference of the two labels.  The
 782    .hword directive will automatically handle the truncation for us.
 783
 784    Returns true if rtx was handled, false otherwise.  */
 785
 786 static bool
 787 v850_output_addr_const_extra (FILE * file, rtx x)
 788 {
 789   if (GET_CODE (x) != TRUNCATE)
 790     return false;
 791
 792   x = XEXP (x, 0);
 793
 794   /* We must also handle the case where the switch table was passed a
 795      constant value and so has been collapsed.  In this case the first
 796      label will have been deleted.  In such a case it is OK to emit
 797      nothing, since the table will not be used.
 798      (cf gcc.c-torture/compile/990801-1.c).  */
 799   if (GET_CODE (x) == MINUS
 800       && GET_CODE (XEXP (x, 0)) == LABEL_REF)
 801     {
 802       rtx_code_label *label
 803         = dyn_cast<rtx_code_label *> (XEXP (XEXP (x, 0), 0));
 804       if (label && label->deleted ())
 805         return true;
 806     }
 807
 808   output_addr_const (file, x);
 809   return true;
 810 }
 811 \f
 812 /* Return appropriate code to load up a 1, 2, or 4 integer/floating
 813    point value.  */
 814
 815 const char *
 816 output_move_single (rtx * operands)
 817 {
 818   rtx dst = operands[0];
 819   rtx src = operands[1];
 820
 821   if (REG_P (dst))
 822     {
 823       if (REG_P (src))
 824         return "mov %1,%0";
 825
 826       else if (GET_CODE (src) == CONST_INT)
 827         {
 828           HOST_WIDE_INT value = INTVAL (src);
 829
 830           if (CONST_OK_FOR_J (value))           /* Signed 5-bit immediate.  */
 831             return "mov %1,%0";
 832
 833           else if (CONST_OK_FOR_K (value))      /* Signed 16-bit immediate.  */
 834             return "movea %1,%.,%0";
 835
 836           else if (CONST_OK_FOR_L (value))      /* Upper 16 bits were set.  */
 837             return "movhi hi0(%1),%.,%0";
 838
 839           /* A random constant.  */
 840           else if (TARGET_V850E_UP)
 841               return "mov %1,%0";
 842           else
 843             return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
 844         }
 845
 846       else if (GET_CODE (src) == CONST_DOUBLE && GET_MODE (src) == SFmode)
 847         {
 848           HOST_WIDE_INT high, low;
 849
 850           const_double_split (src, &high, &low);
 851
 852           if (CONST_OK_FOR_J (high))            /* Signed 5-bit immediate.  */
 853             return "mov %F1,%0";
 854
 855           else if (CONST_OK_FOR_K (high))       /* Signed 16-bit immediate.  */
 856             return "movea %F1,%.,%0";
 857
 858           else if (CONST_OK_FOR_L (high))       /* Upper 16 bits were set.  */
 859             return "movhi hi0(%F1),%.,%0";
 860
 861           /* A random constant.  */
 862         else if (TARGET_V850E_UP)
 863               return "mov %F1,%0";
 864
 865           else
 866             return "movhi hi(%F1),%.,%0\n\tmovea lo(%F1),%0,%0";
 867         }
 868
 869       else if (GET_CODE (src) == MEM)
 870         return "%S1ld%W1 %1,%0";
 871
 872       else if (special_symbolref_operand (src, VOIDmode))
 873         return "movea %O1(%P1),%Q1,%0";
 874
 875       else if (GET_CODE (src) == LABEL_REF
 876                || GET_CODE (src) == SYMBOL_REF
 877                || GET_CODE (src) == CONST)
 878         {
 879           if (TARGET_V850E_UP)
 880             return "mov hilo(%1),%0";
 881           else
 882             return "movhi hi(%1),%.,%0\n\tmovea lo(%1),%0,%0";
 883         }
 884
 885       else if (GET_CODE (src) == HIGH)
 886         return "movhi hi(%1),%.,%0";
 887
 888       else if (GET_CODE (src) == LO_SUM)
 889         {
 890           operands[2] = XEXP (src, 0);
 891           operands[3] = XEXP (src, 1);
 892           return "movea lo(%3),%2,%0";
 893         }
 894     }
 895
 896   else if (GET_CODE (dst) == MEM)
 897     {
 898       if (REG_P (src))
 899         return "%S0st%W0 %1,%0";
 900
 901       else if (GET_CODE (src) == CONST_INT && INTVAL (src) == 0)
 902         return "%S0st%W0 %.,%0";
 903
 904       else if (GET_CODE (src) == CONST_DOUBLE
 905                && CONST0_RTX (GET_MODE (dst)) == src)
 906         return "%S0st%W0 %.,%0";
 907     }
 908
 909   fatal_insn ("output_move_single:", gen_rtx_SET (dst, src));
 910   return "";
 911 }
 912
 913 machine_mode
 914 v850_select_cc_mode (enum rtx_code cond, rtx op0, rtx op1)
 915 {
 916   if (GET_MODE_CLASS (GET_MODE (op0)) == MODE_FLOAT)
 917     {
 918       switch (cond)
 919         {
 920         case LE:
 921           return CC_FPU_LEmode;
 922         case GE:
 923           return CC_FPU_GEmode;
 924         case LT:
 925           return CC_FPU_LTmode;
 926         case GT:
 927           return CC_FPU_GTmode;
 928         case EQ:
 929           return CC_FPU_EQmode;
 930         case NE:
 931           return CC_FPU_NEmode;
 932         default:
 933           gcc_unreachable ();
 934         }
 935     }
 936
 937   if (op1 == const0_rtx
 938       && (cond == EQ || cond == NE || cond == LT || cond == GE)
 939       && (GET_CODE (op0) == PLUS || GET_CODE (op0) == MINUS
 940           || GET_CODE (op0) == NEG || GET_CODE (op0) == AND
 941           || GET_CODE (op0) == IOR || GET_CODE (op0) == XOR
 942           || GET_CODE (op0) == NOT || GET_CODE (op0) == ASHIFT))
 943     return CCNZmode;
 944
 945   return CCmode;
 946 }
 947
 948 machine_mode
 949 v850_gen_float_compare (enum rtx_code cond, machine_mode mode, rtx op0, rtx op1)
 950 {
 951   if (GET_MODE (op0) == DFmode)
 952     {
 953       switch (cond)
 954         {
 955         case LE:
 956           emit_insn (gen_cmpdf_le_insn (op0, op1));
 957           break;
 958         case GE:
 959           emit_insn (gen_cmpdf_ge_insn (op0, op1));
 960           break;
 961         case LT:
 962           emit_insn (gen_cmpdf_lt_insn (op0, op1));
 963           break;
 964         case GT:
 965           emit_insn (gen_cmpdf_gt_insn (op0, op1));
 966           break;
 967         case NE:
 968           /* Note: There is no NE comparison operator. So we
 969              perform an EQ comparison and invert the branch.
 970              See v850_float_nz_comparison for how this is done.  */
 971         case EQ:
 972           emit_insn (gen_cmpdf_eq_insn (op0, op1));
 973           break;
 974         default:
 975           gcc_unreachable ();
 976         }
 977     }
 978   else if (mode == SFmode)
 979     {
 980       switch (cond)
 981         {
 982         case LE:
 983           emit_insn (gen_cmpsf_le_insn(op0, op1));
 984           break;
 985         case GE:
 986           emit_insn (gen_cmpsf_ge_insn(op0, op1));
 987           break;
 988         case LT:
 989           emit_insn (gen_cmpsf_lt_insn(op0, op1));
 990           break;
 991         case GT:
 992           emit_insn (gen_cmpsf_gt_insn(op0, op1));
 993           break;
 994         case NE:
 995           /* Note: There is no NE comparison operator. So we
 996              perform an EQ comparison and invert the branch.
 997              See v850_float_nz_comparison for how this is done.  */
 998         case EQ:
 999           emit_insn (gen_cmpsf_eq_insn(op0, op1));
1000           break;
1001         default:
1002           gcc_unreachable ();
1003         }
1004     }
1005   else
1006     gcc_unreachable ();
1007
1008   return v850_select_cc_mode (cond, op0, op1);
1009 }
1010
1011 /* Return maximum offset supported for a short EP memory reference of mode
1012    MODE and signedness UNSIGNEDP.  */
1013
1014 static int
1015 ep_memory_offset (machine_mode mode, int unsignedp ATTRIBUTE_UNUSED)
1016 {
1017   int max_offset = 0;
1018
1019   switch (mode)
1020     {
1021     case E_QImode:
1022       if (TARGET_SMALL_SLD)
1023         max_offset = (1 << 4);
1024       else if ((TARGET_V850E_UP)
1025                 && unsignedp)
1026         max_offset = (1 << 4);
1027       else
1028         max_offset = (1 << 7);
1029       break;
1030
1031     case E_HImode:
1032       if (TARGET_SMALL_SLD)
1033         max_offset = (1 << 5);
1034       else if ((TARGET_V850E_UP)
1035                 && unsignedp)
1036         max_offset = (1 << 5);
1037       else
1038         max_offset = (1 << 8);
1039       break;
1040
1041     case E_SImode:
1042     case E_SFmode:
1043       max_offset = (1 << 8);
1044       break;
1045
1046     default:
1047       break;
1048     }
1049
1050   return max_offset;
1051 }
1052
1053 /* Return true if OP is a valid short EP memory reference */
1054
1055 int
1056 ep_memory_operand (rtx op, machine_mode mode, int unsigned_load)
1057 {
1058   rtx addr, op0, op1;
1059   int max_offset;
1060   int mask;
1061
1062   /* If we are not using the EP register on a per-function basis
1063      then do not allow this optimization at all.  This is to
1064      prevent the use of the SLD/SST instructions which cannot be
1065      guaranteed to work properly due to a hardware bug.  */
1066   if (!TARGET_EP)
1067     return FALSE;
1068
1069   if (GET_CODE (op) != MEM)
1070     return FALSE;
1071
1072   max_offset = ep_memory_offset (mode, unsigned_load);
1073
1074   mask = GET_MODE_SIZE (mode) - 1;
1075
1076   addr = XEXP (op, 0);
1077   if (GET_CODE (addr) == CONST)
1078     addr = XEXP (addr, 0);
1079
1080   switch (GET_CODE (addr))
1081     {
1082     default:
1083       break;
1084
1085     case SYMBOL_REF:
1086       return SYMBOL_REF_TDA_P (addr);
1087
1088     case REG:
1089       return REGNO (addr) == EP_REGNUM;
1090
1091     case PLUS:
1092       op0 = XEXP (addr, 0);
1093       op1 = XEXP (addr, 1);
1094       if (GET_CODE (op1) == CONST_INT
1095           && INTVAL (op1) < max_offset
1096           && INTVAL (op1) >= 0
1097           && (INTVAL (op1) & mask) == 0)
1098         {
1099           if (GET_CODE (op0) == REG && REGNO (op0) == EP_REGNUM)
1100             return TRUE;
1101
1102           if (GET_CODE (op0) == SYMBOL_REF && SYMBOL_REF_TDA_P (op0))
1103             return TRUE;
1104         }
1105       break;
1106     }
1107
1108   return FALSE;
1109 }
1110 \f
1111 /* Substitute memory references involving a pointer, to use the ep pointer,
1112    taking care to save and preserve the ep.  */
1113
1114 static void
1115 substitute_ep_register (rtx_insn *first_insn,
1116                         rtx_insn *last_insn,
1117                         int uses,
1118                         int regno,
1119                         rtx * p_r1,
1120                         rtx * p_ep)
1121 {
1122   rtx reg = gen_rtx_REG (Pmode, regno);
1123   rtx_insn *insn;
1124
1125   if (!*p_r1)
1126     {
1127       df_set_regs_ever_live (1, true);
1128       *p_r1 = gen_rtx_REG (Pmode, 1);
1129       *p_ep = gen_rtx_REG (Pmode, 30);
1130     }
1131
1132   if (TARGET_DEBUG)
1133     fprintf (stderr, "\
1134 Saved %d bytes (%d uses of register %s) in function %s, starting as insn %d, ending at %d\n",
1135              2 * (uses - 3), uses, reg_names[regno],
1136              IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
1137              INSN_UID (first_insn), INSN_UID (last_insn));
1138
1139   if (NOTE_P (first_insn))
1140     first_insn = next_nonnote_insn (first_insn);
1141
1142   last_insn = next_nonnote_insn (last_insn);
1143   for (insn = first_insn; insn && insn != last_insn; insn = NEXT_INSN (insn))
1144     {
1145       if (NONJUMP_INSN_P (insn))
1146         {
1147           rtx pattern = single_set (insn);
1148
1149           /* Replace the memory references.  */
1150           if (pattern)
1151             {
1152               rtx *p_mem;
1153               /* Memory operands are signed by default.  */
1154               int unsignedp = FALSE;
1155
1156               if (GET_CODE (SET_DEST (pattern)) == MEM
1157                   && GET_CODE (SET_SRC (pattern)) == MEM)
1158                 p_mem = (rtx *)0;
1159
1160               else if (GET_CODE (SET_DEST (pattern)) == MEM)
1161                 p_mem = &SET_DEST (pattern);
1162
1163               else if (GET_CODE (SET_SRC (pattern)) == MEM)
1164                 p_mem = &SET_SRC (pattern);
1165
1166               else if (GET_CODE (SET_SRC (pattern)) == SIGN_EXTEND
1167                        && GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
1168                 p_mem = &XEXP (SET_SRC (pattern), 0);
1169
1170               else if (GET_CODE (SET_SRC (pattern)) == ZERO_EXTEND
1171                        && GET_CODE (XEXP (SET_SRC (pattern), 0)) == MEM)
1172                 {
1173                   p_mem = &XEXP (SET_SRC (pattern), 0);
1174                   unsignedp = TRUE;
1175                 }
1176               else
1177                 p_mem = (rtx *)0;
1178
1179               if (p_mem)
1180                 {
1181                   rtx addr = XEXP (*p_mem, 0);
1182
1183                   if (GET_CODE (addr) == REG && REGNO (addr) == (unsigned) regno)
1184                     *p_mem = change_address (*p_mem, VOIDmode, *p_ep);
1185
1186                   else if (GET_CODE (addr) == PLUS
1187                            && GET_CODE (XEXP (addr, 0)) == REG
1188                            && REGNO (XEXP (addr, 0)) == (unsigned) regno
1189                            && GET_CODE (XEXP (addr, 1)) == CONST_INT
1190                            && ((INTVAL (XEXP (addr, 1)))
1191                                < ep_memory_offset (GET_MODE (*p_mem),
1192                                                    unsignedp))
1193                            && ((INTVAL (XEXP (addr, 1))) >= 0))
1194                     *p_mem = change_address (*p_mem, VOIDmode,
1195                                              gen_rtx_PLUS (Pmode,
1196                                                            *p_ep,
1197                                                            XEXP (addr, 1)));
1198                 }
1199             }
1200         }
1201     }
1202
1203   /* Optimize back to back cases of ep <- r1 & r1 <- ep.  */
1204   insn = prev_nonnote_insn (first_insn);
1205   if (insn && NONJUMP_INSN_P (insn)
1206       && GET_CODE (PATTERN (insn)) == SET
1207       && SET_DEST (PATTERN (insn)) == *p_ep
1208       && SET_SRC (PATTERN (insn)) == *p_r1)
1209     delete_insn (insn);
1210   else
1211     emit_insn_before (gen_rtx_SET (*p_r1, *p_ep), first_insn);
1212
1213   emit_insn_before (gen_rtx_SET (*p_ep, reg), first_insn);
1214   emit_insn_before (gen_rtx_SET (*p_ep, *p_r1), last_insn);
1215 }
1216
1217 \f
1218 /* TARGET_MACHINE_DEPENDENT_REORG.  On the 850, we use it to implement
1219    the -mep mode to copy heavily used pointers to ep to use the implicit
1220    addressing.  */
1221
1222 static void
1223 v850_reorg (void)
1224 {
1225   struct
1226   {
1227     int uses;
1228     rtx_insn *first_insn;
1229     rtx_insn *last_insn;
1230   }
1231   regs[FIRST_PSEUDO_REGISTER];
1232
1233   int i;
1234   int use_ep = FALSE;
1235   rtx r1 = NULL_RTX;
1236   rtx ep = NULL_RTX;
1237   rtx_insn *insn;
1238   rtx pattern;
1239
1240   /* If not ep mode, just return now.  */
1241   if (!TARGET_EP)
1242     return;
1243
1244   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1245     {
1246       regs[i].uses = 0;
1247       regs[i].first_insn = NULL;
1248       regs[i].last_insn = NULL;
1249     }
1250
1251   for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn))
1252     {
1253       switch (GET_CODE (insn))
1254         {
1255           /* End of basic block */
1256         default:
1257           if (!use_ep)
1258             {
1259               int max_uses = -1;
1260               int max_regno = -1;
1261
1262               for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1263                 {
1264                   if (max_uses < regs[i].uses)
1265                     {
1266                       max_uses = regs[i].uses;
1267                       max_regno = i;
1268                     }
1269                 }
1270
1271               if (max_uses > 3)
1272                 substitute_ep_register (regs[max_regno].first_insn,
1273                                         regs[max_regno].last_insn,
1274                                         max_uses, max_regno, &r1, &ep);
1275             }
1276
1277           use_ep = FALSE;
1278           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1279             {
1280               regs[i].uses = 0;
1281               regs[i].first_insn = NULL;
1282               regs[i].last_insn = NULL;
1283             }
1284           break;
1285
1286         case NOTE:
1287           break;
1288
1289         case INSN:
1290           pattern = single_set (insn);
1291
1292           /* See if there are any memory references we can shorten.  */
1293           if (pattern)
1294             {
1295               rtx src = SET_SRC (pattern);
1296               rtx dest = SET_DEST (pattern);
1297               rtx mem;
1298               /* Memory operands are signed by default.  */
1299               int unsignedp = FALSE;
1300
1301               /* We might have (SUBREG (MEM)) here, so just get rid of the
1302                  subregs to make this code simpler.  */
1303               if (GET_CODE (dest) == SUBREG
1304                   && (GET_CODE (SUBREG_REG (dest)) == MEM
1305                       || GET_CODE (SUBREG_REG (dest)) == REG))
1306                 alter_subreg (&dest, false);
1307               if (GET_CODE (src) == SUBREG
1308                   && (GET_CODE (SUBREG_REG (src)) == MEM
1309                       || GET_CODE (SUBREG_REG (src)) == REG))
1310                 alter_subreg (&src, false);
1311
1312               if (GET_CODE (dest) == MEM && GET_CODE (src) == MEM)
1313                 mem = NULL_RTX;
1314
1315               else if (GET_CODE (dest) == MEM)
1316                 mem = dest;
1317
1318               else if (GET_CODE (src) == MEM)
1319                 mem = src;
1320
1321               else if (GET_CODE (src) == SIGN_EXTEND
1322                        && GET_CODE (XEXP (src, 0)) == MEM)
1323                 mem = XEXP (src, 0);
1324
1325               else if (GET_CODE (src) == ZERO_EXTEND
1326                        && GET_CODE (XEXP (src, 0)) == MEM)
1327                 {
1328                   mem = XEXP (src, 0);
1329                   unsignedp = TRUE;
1330                 }
1331               else
1332                 mem = NULL_RTX;
1333
1334               if (mem && ep_memory_operand (mem, GET_MODE (mem), unsignedp))
1335                 use_ep = TRUE;
1336
1337               else if (!use_ep && mem
1338                        && GET_MODE_SIZE (GET_MODE (mem)) <= UNITS_PER_WORD)
1339                 {
1340                   rtx addr = XEXP (mem, 0);
1341                   int regno = -1;
1342                   int short_p;
1343
1344                   if (GET_CODE (addr) == REG)
1345                     {
1346                       short_p = TRUE;
1347                       regno = REGNO (addr);
1348                     }
1349
1350                   else if (GET_CODE (addr) == PLUS
1351                            && GET_CODE (XEXP (addr, 0)) == REG
1352                            && GET_CODE (XEXP (addr, 1)) == CONST_INT
1353                            && ((INTVAL (XEXP (addr, 1)))
1354                                < ep_memory_offset (GET_MODE (mem), unsignedp))
1355                            && ((INTVAL (XEXP (addr, 1))) >= 0))
1356                     {
1357                       short_p = TRUE;
1358                       regno = REGNO (XEXP (addr, 0));
1359                     }
1360
1361                   else
1362                     short_p = FALSE;
1363
1364                   if (short_p)
1365                     {
1366                       regs[regno].uses++;
1367                       regs[regno].last_insn = insn;
1368                       if (!regs[regno].first_insn)
1369                         regs[regno].first_insn = insn;
1370                     }
1371                 }
1372
1373               /* Loading up a register in the basic block zaps any savings
1374                  for the register */
1375               if (GET_CODE (dest) == REG)
1376                 {
1377                   int regno;
1378                   int endregno;
1379
1380                   regno = REGNO (dest);
1381                   endregno = END_REGNO (dest);
1382
1383                   if (!use_ep)
1384                     {
1385                       /* See if we can use the pointer before this
1386                          modification.  */
1387                       int max_uses = -1;
1388                       int max_regno = -1;
1389
1390                       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1391                         {
1392                           if (max_uses < regs[i].uses)
1393                             {
1394                               max_uses = regs[i].uses;
1395                               max_regno = i;
1396                             }
1397                         }
1398
1399                       if (max_uses > 3
1400                           && max_regno >= regno
1401                           && max_regno < endregno)
1402                         {
1403                           substitute_ep_register (regs[max_regno].first_insn,
1404                                                   regs[max_regno].last_insn,
1405                                                   max_uses, max_regno, &r1,
1406                                                   &ep);
1407
1408                           /* Since we made a substitution, zap all remembered
1409                              registers.  */
1410                           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1411                             {
1412                               regs[i].uses = 0;
1413                               regs[i].first_insn = NULL;
1414                               regs[i].last_insn = NULL;
1415                             }
1416                         }
1417                     }
1418
1419                   for (i = regno; i < endregno; i++)
1420                     {
1421                       regs[i].uses = 0;
1422                       regs[i].first_insn = NULL;
1423                       regs[i].last_insn = NULL;
1424                     }
1425                 }
1426             }
1427         }
1428     }
1429 }
1430
1431 /* # of registers saved by the interrupt handler.  */
1432 #define INTERRUPT_FIXED_NUM 5
1433
1434 /* # of bytes for registers saved by the interrupt handler.  */
1435 #define INTERRUPT_FIXED_SAVE_SIZE (4 * INTERRUPT_FIXED_NUM)
1436
1437 /* # of words saved for other registers.  */
1438 #define INTERRUPT_ALL_SAVE_NUM \
1439   (30 - INTERRUPT_FIXED_NUM)
1440
1441 #define INTERRUPT_ALL_SAVE_SIZE (4 * INTERRUPT_ALL_SAVE_NUM)
1442
1443 int
1444 compute_register_save_size (long * p_reg_saved)
1445 {
1446   int size = 0;
1447   int i;
1448   int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1449   int call_p = df_regs_ever_live_p (LINK_POINTER_REGNUM);
1450   long reg_saved = 0;
1451
1452   /* Count space for the register saves.  */
1453   if (interrupt_handler)
1454     {
1455       for (i = 0; i <= 31; i++)
1456         switch (i)
1457           {
1458           default:
1459             if (df_regs_ever_live_p (i) || call_p)
1460               {
1461                 size += 4;
1462                 reg_saved |= 1L << i;
1463               }
1464             break;
1465
1466             /* We don't save/restore r0 or the stack pointer */
1467           case 0:
1468           case STACK_POINTER_REGNUM:
1469             break;
1470
1471             /* For registers with fixed use, we save them, set them to the
1472                appropriate value, and then restore them.
1473                These registers are handled specially, so don't list them
1474                on the list of registers to save in the prologue.  */
1475           case 1:               /* temp used to hold ep */
1476           case 4:               /* gp */
1477           case 10:              /* temp used to call interrupt save/restore */
1478           case 11:              /* temp used to call interrupt save/restore (long call) */
1479           case EP_REGNUM:       /* ep */
1480             size += 4;
1481             break;
1482           }
1483     }
1484   else
1485     {
1486       /* Find the first register that needs to be saved.  */
1487       for (i = 0; i <= 31; i++)
1488         if (df_regs_ever_live_p (i) && ((! call_used_regs[i])
1489                                   || i == LINK_POINTER_REGNUM))
1490           break;
1491
1492       /* If it is possible that an out-of-line helper function might be
1493          used to generate the prologue for the current function, then we
1494          need to cover the possibility that such a helper function will
1495          be used, despite the fact that there might be gaps in the list of
1496          registers that need to be saved.  To detect this we note that the
1497          helper functions always push at least register r29 (provided
1498          that the function is not an interrupt handler).  */
1499
1500       if (TARGET_PROLOG_FUNCTION
1501           && (i == 2 || ((i >= 20) && (i < 30))))
1502         {
1503           if (i == 2)
1504             {
1505               size += 4;
1506               reg_saved |= 1L << i;
1507
1508               i = 20;
1509             }
1510
1511           /* Helper functions save all registers between the starting
1512              register and the last register, regardless of whether they
1513              are actually used by the function or not.  */
1514           for (; i <= 29; i++)
1515             {
1516               size += 4;
1517               reg_saved |= 1L << i;
1518             }
1519
1520           if (df_regs_ever_live_p (LINK_POINTER_REGNUM))
1521             {
1522               size += 4;
1523               reg_saved |= 1L << LINK_POINTER_REGNUM;
1524             }
1525         }
1526       else
1527         {
1528           for (; i <= 31; i++)
1529             if (df_regs_ever_live_p (i) && ((! call_used_regs[i])
1530                                       || i == LINK_POINTER_REGNUM))
1531               {
1532                 size += 4;
1533                 reg_saved |= 1L << i;
1534               }
1535         }
1536     }
1537
1538   if (p_reg_saved)
1539     *p_reg_saved = reg_saved;
1540
1541   return size;
1542 }
1543
1544 /* Typical stack layout should looks like this after the function's prologue:
1545
1546                             |    |
1547                               --                       ^
1548                             |    | \                   |
1549                             |    |   arguments saved   | Increasing
1550                             |    |   on the stack      |  addresses
1551     PARENT   arg pointer -> |    | /
1552   -------------------------- ---- -------------------
1553                             |    | - space for argument split between regs & stack
1554                               --
1555     CHILD                   |    | \    <-- (return address here)
1556                             |    |   other call
1557                             |    |   saved registers
1558                             |    | /
1559                               --
1560         frame pointer ->    |    | \             ___
1561                             |    |   local        |
1562                             |    |   variables    |f
1563                             |    | /              |r
1564                               --                  |a
1565                             |    | \              |m
1566                             |    |   outgoing     |e
1567                             |    |   arguments    |    | Decreasing
1568     (hard) frame pointer    |    |  /             |    |  addresses
1569        and stack pointer -> |    | /             _|_   |
1570   -------------------------- ---- ------------------   V */
1571
1572 int
1573 compute_frame_size (poly_int64 size, long * p_reg_saved)
1574 {
1575   return (size
1576           + compute_register_save_size (p_reg_saved)
1577           + crtl->outgoing_args_size);
1578 }
1579
1580 static int
1581 use_prolog_function (int num_save, int frame_size)
1582 {
1583   int alloc_stack = (4 * num_save);
1584   int unalloc_stack = frame_size - alloc_stack;
1585   int save_func_len, restore_func_len;
1586   int save_normal_len, restore_normal_len;
1587
1588   if (! TARGET_DISABLE_CALLT)
1589       save_func_len = restore_func_len = 2;
1590   else
1591       save_func_len = restore_func_len = TARGET_LONG_CALLS ? (4+4+4+2+2) : 4;
1592
1593   if (unalloc_stack)
1594     {
1595       save_func_len += CONST_OK_FOR_J (-unalloc_stack) ? 2 : 4;
1596       restore_func_len += CONST_OK_FOR_J (-unalloc_stack) ? 2 : 4;
1597     }
1598
1599   /* See if we would have used ep to save the stack.  */
1600   if (TARGET_EP && num_save > 3 && (unsigned)frame_size < 255)
1601     save_normal_len = restore_normal_len = (3 * 2) + (2 * num_save);
1602   else
1603     save_normal_len = restore_normal_len = 4 * num_save;
1604
1605   save_normal_len += CONST_OK_FOR_J (-frame_size) ? 2 : 4;
1606   restore_normal_len += (CONST_OK_FOR_J (frame_size) ? 2 : 4) + 2;
1607
1608   /* Don't bother checking if we don't actually save any space.
1609      This happens for instance if one register is saved and additional
1610      stack space is allocated.  */
1611   return ((save_func_len + restore_func_len) < (save_normal_len + restore_normal_len));
1612 }
1613
1614 static void
1615 increment_stack (signed int amount, bool in_prologue)
1616 {
1617   rtx inc;
1618
1619   if (amount == 0)
1620     return;
1621
1622   inc = GEN_INT (amount);
1623
1624   if (! CONST_OK_FOR_K (amount))
1625     {
1626       rtx reg = gen_rtx_REG (Pmode, 12);
1627
1628       inc = emit_move_insn (reg, inc);
1629       if (in_prologue)
1630         F (inc);
1631       inc = reg;
1632     }
1633
1634   inc = emit_insn (gen_addsi3_clobber_flags (stack_pointer_rtx, stack_pointer_rtx, inc));
1635   if (in_prologue)
1636     F (inc);
1637 }
1638
1639 void
1640 expand_prologue (void)
1641 {
1642   unsigned int i;
1643   unsigned int size = get_frame_size ();
1644   unsigned int actual_fsize;
1645   unsigned int init_stack_alloc = 0;
1646   rtx save_regs[32];
1647   rtx save_all;
1648   unsigned int num_save;
1649   int code;
1650   int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1651   long reg_saved = 0;
1652
1653   actual_fsize = compute_frame_size (size, &reg_saved);
1654
1655   if (flag_stack_usage_info)
1656     current_function_static_stack_size = actual_fsize;
1657
1658   /* Save/setup global registers for interrupt functions right now.  */
1659   if (interrupt_handler)
1660     {
1661       if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
1662         emit_insn (gen_callt_save_interrupt ());
1663       else
1664         emit_insn (gen_save_interrupt ());
1665
1666       actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
1667
1668       if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1669         actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
1670
1671       /* Interrupt functions are not passed arguments, so no need to
1672          allocate space for split structure arguments.  */
1673       gcc_assert (crtl->args.pretend_args_size == 0);
1674     }
1675
1676   /* Identify all of the saved registers.  */
1677   num_save = 0;
1678   for (i = 1; i < 32; i++)
1679     {
1680       if (((1L << i) & reg_saved) != 0)
1681         save_regs[num_save++] = gen_rtx_REG (Pmode, i);
1682     }
1683
1684   if (crtl->args.pretend_args_size)
1685     {
1686       if (num_save == 0)
1687         {
1688           increment_stack (- (actual_fsize + crtl->args.pretend_args_size), true);
1689           actual_fsize = 0;
1690         }
1691       else
1692         increment_stack (- crtl->args.pretend_args_size, true);
1693     }
1694
1695   /* See if we have an insn that allocates stack space and saves the particular
1696      registers we want to.  Note that the helpers won't
1697      allocate additional space for registers GCC saves to complete a
1698      "split" structure argument.  */
1699   save_all = NULL_RTX;
1700   if (TARGET_PROLOG_FUNCTION
1701       && !crtl->args.pretend_args_size
1702       && num_save > 0)
1703     {
1704       if (use_prolog_function (num_save, actual_fsize))
1705         {
1706           int alloc_stack = 4 * num_save;
1707           int offset = 0;
1708
1709           save_all = gen_rtx_PARALLEL
1710             (VOIDmode,
1711              rtvec_alloc (num_save + 2
1712                           + (TARGET_DISABLE_CALLT ? (TARGET_LONG_CALLS ? 2 : 1) : 0)));
1713
1714           XVECEXP (save_all, 0, 0)
1715             = gen_rtx_SET (stack_pointer_rtx,
1716                            gen_rtx_PLUS (Pmode,
1717                                          stack_pointer_rtx,
1718                                          GEN_INT(-alloc_stack)));
1719           for (i = 0; i < num_save; i++)
1720             {
1721               offset -= 4;
1722               XVECEXP (save_all, 0, i+1)
1723                 = gen_rtx_SET (gen_rtx_MEM (Pmode,
1724                                             gen_rtx_PLUS (Pmode,
1725                                                           stack_pointer_rtx,
1726                                                           GEN_INT(offset))),
1727                                save_regs[i]);
1728             }
1729
1730           XVECEXP (save_all, 0, num_save + 1)
1731             = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, CC_REGNUM));
1732
1733           if (TARGET_DISABLE_CALLT)
1734             {
1735               XVECEXP (save_all, 0, num_save + 2)
1736                 = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 10));
1737
1738               if (TARGET_LONG_CALLS)
1739                 XVECEXP (save_all, 0, num_save + 3)
1740                   = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 11));
1741             }
1742
1743           v850_all_frame_related (save_all);
1744
1745           code = recog (save_all, NULL, NULL);
1746           if (code >= 0)
1747             {
1748               rtx insn = emit_insn (save_all);
1749               INSN_CODE (insn) = code;
1750               actual_fsize -= alloc_stack;
1751
1752             }
1753           else
1754             save_all = NULL_RTX;
1755         }
1756     }
1757
1758   /* If no prolog save function is available, store the registers the old
1759      fashioned way (one by one).  */
1760   if (!save_all)
1761     {
1762       /* Special case interrupt functions that save all registers for a call.  */
1763       if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1764         {
1765           if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
1766             emit_insn (gen_callt_save_all_interrupt ());
1767           else
1768             emit_insn (gen_save_all_interrupt ());
1769         }
1770       else
1771         {
1772           int offset;
1773           /* If the stack is too big, allocate it in chunks so we can do the
1774              register saves.  We use the register save size so we use the ep
1775              register.  */
1776           if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
1777             init_stack_alloc = compute_register_save_size (NULL);
1778           else
1779             init_stack_alloc = actual_fsize;
1780
1781           /* Save registers at the beginning of the stack frame.  */
1782           offset = init_stack_alloc - 4;
1783
1784           if (init_stack_alloc)
1785             increment_stack (- (signed) init_stack_alloc, true);
1786
1787           /* Save the return pointer first.  */
1788           if (num_save > 0 && REGNO (save_regs[num_save-1]) == LINK_POINTER_REGNUM)
1789             {
1790               F (emit_move_insn (gen_rtx_MEM (SImode,
1791                                               plus_constant (Pmode,
1792                                                              stack_pointer_rtx,
1793                                                              offset)),
1794                                  save_regs[--num_save]));
1795               offset -= 4;
1796             }
1797
1798           for (i = 0; i < num_save; i++)
1799             {
1800               F (emit_move_insn (gen_rtx_MEM (SImode,
1801                                               plus_constant (Pmode,
1802                                                              stack_pointer_rtx,
1803                                                              offset)),
1804                                  save_regs[i]));
1805               offset -= 4;
1806             }
1807         }
1808     }
1809
1810   /* Allocate the rest of the stack that was not allocated above (either it is
1811      > 32K or we just called a function to save the registers and needed more
1812      stack.  */
1813   if (actual_fsize > init_stack_alloc)
1814     increment_stack (init_stack_alloc - actual_fsize, true);
1815
1816   /* If we need a frame pointer, set it up now.  */
1817   if (frame_pointer_needed)
1818     F (emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx));
1819 }
1820 \f
1821
1822 void
1823 expand_epilogue (void)
1824 {
1825   unsigned int i;
1826   unsigned int size = get_frame_size ();
1827   long reg_saved = 0;
1828   int actual_fsize = compute_frame_size (size, &reg_saved);
1829   rtx restore_regs[32];
1830   rtx restore_all;
1831   unsigned int num_restore;
1832   int code;
1833   int interrupt_handler = v850_interrupt_function_p (current_function_decl);
1834
1835   /* Eliminate the initial stack stored by interrupt functions.  */
1836   if (interrupt_handler)
1837     {
1838       actual_fsize -= INTERRUPT_FIXED_SAVE_SIZE;
1839       if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1840         actual_fsize -= INTERRUPT_ALL_SAVE_SIZE;
1841     }
1842
1843   /* Cut off any dynamic stack created.  */
1844   if (frame_pointer_needed)
1845     emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx);
1846
1847   /* Identify all of the saved registers.  */
1848   num_restore = 0;
1849   for (i = 1; i < 32; i++)
1850     {
1851       if (((1L << i) & reg_saved) != 0)
1852         restore_regs[num_restore++] = gen_rtx_REG (Pmode, i);
1853     }
1854
1855   /* See if we have an insn that restores the particular registers we
1856      want to.  */
1857   restore_all = NULL_RTX;
1858
1859   if (TARGET_PROLOG_FUNCTION
1860       && num_restore > 0
1861       && !crtl->args.pretend_args_size
1862       && !interrupt_handler)
1863     {
1864       int alloc_stack = (4 * num_restore);
1865
1866       /* Don't bother checking if we don't actually save any space.  */
1867       if (use_prolog_function (num_restore, actual_fsize))
1868         {
1869           int offset;
1870           restore_all = gen_rtx_PARALLEL (VOIDmode,
1871                                           rtvec_alloc (num_restore + 2));
1872           XVECEXP (restore_all, 0, 0) = ret_rtx;
1873           XVECEXP (restore_all, 0, 1)
1874             = gen_rtx_SET (stack_pointer_rtx,
1875                            gen_rtx_PLUS (Pmode,
1876                                          stack_pointer_rtx,
1877                                          GEN_INT (alloc_stack)));
1878
1879           offset = alloc_stack - 4;
1880           for (i = 0; i < num_restore; i++)
1881             {
1882               XVECEXP (restore_all, 0, i+2)
1883                 = gen_rtx_SET (restore_regs[i],
1884                                gen_rtx_MEM (Pmode,
1885                                             gen_rtx_PLUS (Pmode,
1886                                                           stack_pointer_rtx,
1887                                                           GEN_INT(offset))));
1888               offset -= 4;
1889             }
1890
1891           code = recog (restore_all, NULL, NULL);
1892
1893           if (code >= 0)
1894             {
1895               rtx insn;
1896
1897               actual_fsize -= alloc_stack;
1898               increment_stack (actual_fsize, false);
1899
1900               insn = emit_jump_insn (restore_all);
1901               INSN_CODE (insn) = code;
1902             }
1903           else
1904             restore_all = NULL_RTX;
1905         }
1906     }
1907
1908   /* If no epilogue save function is available, restore the registers the
1909      old fashioned way (one by one).  */
1910   if (!restore_all)
1911     {
1912       unsigned int init_stack_free;
1913
1914       /* If the stack is large, we need to cut it down in 2 pieces.  */
1915       if (interrupt_handler)
1916        init_stack_free = 0;
1917       else if (actual_fsize && !CONST_OK_FOR_K (-actual_fsize))
1918         init_stack_free = 4 * num_restore;
1919       else
1920         init_stack_free = (signed) actual_fsize;
1921
1922       /* Deallocate the rest of the stack if it is > 32K.  */
1923       if ((unsigned int) actual_fsize > init_stack_free)
1924         increment_stack (actual_fsize - init_stack_free, false);
1925
1926       /* Special case interrupt functions that save all registers
1927          for a call.  */
1928       if (interrupt_handler && ((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
1929         {
1930           if (! TARGET_DISABLE_CALLT)
1931             emit_insn (gen_callt_restore_all_interrupt ());
1932           else
1933             emit_insn (gen_restore_all_interrupt ());
1934         }
1935       else
1936         {
1937           /* Restore registers from the beginning of the stack frame.  */
1938           int offset = init_stack_free - 4;
1939
1940           /* Restore the return pointer first.  */
1941           if (num_restore > 0
1942               && REGNO (restore_regs [num_restore - 1]) == LINK_POINTER_REGNUM)
1943             {
1944               emit_move_insn (restore_regs[--num_restore],
1945                               gen_rtx_MEM (SImode,
1946                                            plus_constant (Pmode,
1947                                                           stack_pointer_rtx,
1948                                                           offset)));
1949               offset -= 4;
1950             }
1951
1952           for (i = 0; i < num_restore; i++)
1953             {
1954               emit_move_insn (restore_regs[i],
1955                               gen_rtx_MEM (SImode,
1956                                            plus_constant (Pmode,
1957                                                           stack_pointer_rtx,
1958                                                           offset)));
1959
1960               emit_use (restore_regs[i]);
1961               offset -= 4;
1962             }
1963
1964           /* Cut back the remainder of the stack.  */
1965           increment_stack (init_stack_free + crtl->args.pretend_args_size,
1966                            false);
1967         }
1968
1969       /* And return or use reti for interrupt handlers.  */
1970       if (interrupt_handler)
1971         {
1972           if (! TARGET_DISABLE_CALLT && (TARGET_V850E_UP))
1973             emit_insn (gen_callt_return_interrupt ());
1974           else
1975             emit_jump_insn (gen_return_interrupt ());
1976          }
1977       else if (actual_fsize)
1978         emit_jump_insn (gen_return_internal ());
1979       else
1980         emit_jump_insn (gen_return_simple ());
1981     }
1982
1983   v850_interrupt_cache_p = FALSE;
1984   v850_interrupt_p = FALSE;
1985 }
1986
1987 /* Retrieve the data area that has been chosen for the given decl.  */
1988
1989 v850_data_area
1990 v850_get_data_area (tree decl)
1991 {
1992   if (lookup_attribute ("sda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
1993     return DATA_AREA_SDA;
1994
1995   if (lookup_attribute ("tda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
1996     return DATA_AREA_TDA;
1997
1998   if (lookup_attribute ("zda", DECL_ATTRIBUTES (decl)) != NULL_TREE)
1999     return DATA_AREA_ZDA;
2000
2001   return DATA_AREA_NORMAL;
2002 }
2003
2004 /* Store the indicated data area in the decl's attributes.  */
2005
2006 static void
2007 v850_set_data_area (tree decl, v850_data_area data_area)
2008 {
2009   tree name;
2010
2011   switch (data_area)
2012     {
2013     case DATA_AREA_SDA: name = get_identifier ("sda"); break;
2014     case DATA_AREA_TDA: name = get_identifier ("tda"); break;
2015     case DATA_AREA_ZDA: name = get_identifier ("zda"); break;
2016     default:
2017       return;
2018     }
2019
2020   DECL_ATTRIBUTES (decl) = tree_cons
2021     (name, NULL, DECL_ATTRIBUTES (decl));
2022 }
2023 \f
2024 /* Handle an "interrupt" attribute; arguments as in
2025    struct attribute_spec.handler.  */
2026 static tree
2027 v850_handle_interrupt_attribute (tree *node, tree name,
2028                                  tree args ATTRIBUTE_UNUSED,
2029                                  int flags ATTRIBUTE_UNUSED,
2030                                  bool * no_add_attrs)
2031 {
2032   if (TREE_CODE (*node) != FUNCTION_DECL)
2033     {
2034       warning (OPT_Wattributes, "%qE attribute only applies to functions",
2035                name);
2036       *no_add_attrs = true;
2037     }
2038
2039   return NULL_TREE;
2040 }
2041
2042 /* Handle a "sda", "tda" or "zda" attribute; arguments as in
2043    struct attribute_spec.handler.  */
2044 static tree
2045 v850_handle_data_area_attribute (tree *node, tree name,
2046                                  tree args ATTRIBUTE_UNUSED,
2047                                  int flags ATTRIBUTE_UNUSED,
2048                                  bool * no_add_attrs)
2049 {
2050   v850_data_area data_area;
2051   v850_data_area area;
2052   tree decl = *node;
2053
2054   /* Implement data area attribute.  */
2055   if (is_attribute_p ("sda", name))
2056     data_area = DATA_AREA_SDA;
2057   else if (is_attribute_p ("tda", name))
2058     data_area = DATA_AREA_TDA;
2059   else if (is_attribute_p ("zda", name))
2060     data_area = DATA_AREA_ZDA;
2061   else
2062     gcc_unreachable ();
2063
2064   switch (TREE_CODE (decl))
2065     {
2066     case VAR_DECL:
2067       if (current_function_decl != NULL_TREE)
2068         {
2069           error_at (DECL_SOURCE_LOCATION (decl),
2070                     "data area attributes cannot be specified for "
2071                     "local variables");
2072           *no_add_attrs = true;
2073         }
2074
2075       /* FALLTHRU */
2076
2077     case FUNCTION_DECL:
2078       area = v850_get_data_area (decl);
2079       if (area != DATA_AREA_NORMAL && data_area != area)
2080         {
2081           error ("data area of %q+D conflicts with previous declaration",
2082                  decl);
2083           *no_add_attrs = true;
2084         }
2085       break;
2086
2087     default:
2088       break;
2089     }
2090
2091   return NULL_TREE;
2092 }
2093
2094 \f
2095 /* Return nonzero if FUNC is an interrupt function as specified
2096    by the "interrupt" attribute.  */
2097
2098 int
2099 v850_interrupt_function_p (tree func)
2100 {
2101   tree a;
2102   int ret = 0;
2103
2104   if (v850_interrupt_cache_p)
2105     return v850_interrupt_p;
2106
2107   if (TREE_CODE (func) != FUNCTION_DECL)
2108     return 0;
2109
2110   a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
2111   if (a != NULL_TREE)
2112     ret = 1;
2113
2114   else
2115     {
2116       a = lookup_attribute ("interrupt", DECL_ATTRIBUTES (func));
2117       ret = a != NULL_TREE;
2118     }
2119
2120   /* Its not safe to trust global variables until after function inlining has
2121      been done.  */
2122   if (reload_completed | reload_in_progress)
2123     v850_interrupt_p = ret;
2124
2125   return ret;
2126 }
2127
2128 \f
2129 static void
2130 v850_encode_data_area (tree decl, rtx symbol)
2131 {
2132   int flags;
2133
2134   /* Map explicit sections into the appropriate attribute */
2135   if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
2136     {
2137       if (DECL_SECTION_NAME (decl))
2138         {
2139           const char *name = DECL_SECTION_NAME (decl);
2140
2141           if (streq (name, ".zdata") || streq (name, ".zbss"))
2142             v850_set_data_area (decl, DATA_AREA_ZDA);
2143
2144           else if (streq (name, ".sdata") || streq (name, ".sbss"))
2145             v850_set_data_area (decl, DATA_AREA_SDA);
2146
2147           else if (streq (name, ".tdata"))
2148             v850_set_data_area (decl, DATA_AREA_TDA);
2149         }
2150
2151       /* If no attribute, support -m{zda,sda,tda}=n */
2152       else
2153         {
2154           int size = int_size_in_bytes (TREE_TYPE (decl));
2155           if (size <= 0)
2156             ;
2157
2158           else if (size <= small_memory_max [(int) SMALL_MEMORY_TDA])
2159             v850_set_data_area (decl, DATA_AREA_TDA);
2160
2161           else if (size <= small_memory_max [(int) SMALL_MEMORY_SDA])
2162             v850_set_data_area (decl, DATA_AREA_SDA);
2163
2164           else if (size <= small_memory_max [(int) SMALL_MEMORY_ZDA])
2165             v850_set_data_area (decl, DATA_AREA_ZDA);
2166         }
2167
2168       if (v850_get_data_area (decl) == DATA_AREA_NORMAL)
2169         return;
2170     }
2171
2172   flags = SYMBOL_REF_FLAGS (symbol);
2173   switch (v850_get_data_area (decl))
2174     {
2175     case DATA_AREA_ZDA: flags |= SYMBOL_FLAG_ZDA; break;
2176     case DATA_AREA_TDA: flags |= SYMBOL_FLAG_TDA; break;
2177     case DATA_AREA_SDA: flags |= SYMBOL_FLAG_SDA; break;
2178     default: gcc_unreachable ();
2179     }
2180   SYMBOL_REF_FLAGS (symbol) = flags;
2181 }
2182
2183 static void
2184 v850_encode_section_info (tree decl, rtx rtl, int first)
2185 {
2186   default_encode_section_info (decl, rtl, first);
2187
2188   if (TREE_CODE (decl) == VAR_DECL
2189       && (TREE_STATIC (decl) || DECL_EXTERNAL (decl)))
2190     v850_encode_data_area (decl, XEXP (rtl, 0));
2191 }
2192
2193 /* Construct a JR instruction to a routine that will perform the equivalent of
2194    the RTL passed in as an argument.  This RTL is a function epilogue that
2195    pops registers off the stack and possibly releases some extra stack space
2196    as well.  The code has already verified that the RTL matches these
2197    requirements.  */
2198
2199 char *
2200 construct_restore_jr (rtx op)
2201 {
2202   int count = XVECLEN (op, 0);
2203   int stack_bytes;
2204   unsigned long int mask;
2205   unsigned long int first;
2206   unsigned long int last;
2207   int i;
2208   static char buff [100]; /* XXX */
2209
2210   if (count <= 2)
2211     {
2212       error ("bogus JR construction: %d", count);
2213       return NULL;
2214     }
2215
2216   /* Work out how many bytes to pop off the stack before retrieving
2217      registers.  */
2218   gcc_assert (GET_CODE (XVECEXP (op, 0, 1)) == SET);
2219   gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS);
2220   gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) == CONST_INT);
2221
2222   stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
2223
2224   /* Each pop will remove 4 bytes from the stack....  */
2225   stack_bytes -= (count - 2) * 4;
2226
2227   /* Make sure that the amount we are popping either 0 or 16 bytes.  */
2228   if (stack_bytes != 0)
2229     {
2230       error ("bad amount of stack space removal: %d", stack_bytes);
2231       return NULL;
2232     }
2233
2234   /* Now compute the bit mask of registers to push.  */
2235   mask = 0;
2236   for (i = 2; i < count; i++)
2237     {
2238       rtx vector_element = XVECEXP (op, 0, i);
2239
2240       gcc_assert (GET_CODE (vector_element) == SET);
2241       gcc_assert (GET_CODE (SET_DEST (vector_element)) == REG);
2242       gcc_assert (register_is_ok_for_epilogue (SET_DEST (vector_element),
2243                                                SImode));
2244
2245       mask |= 1 << REGNO (SET_DEST (vector_element));
2246     }
2247
2248   /* Scan for the first register to pop.  */
2249   for (first = 0; first < 32; first++)
2250     {
2251       if (mask & (1 << first))
2252         break;
2253     }
2254
2255   gcc_assert (first < 32);
2256
2257   /* Discover the last register to pop.  */
2258   if (mask & (1 << LINK_POINTER_REGNUM))
2259     {
2260       last = LINK_POINTER_REGNUM;
2261     }
2262   else
2263     {
2264       gcc_assert (!stack_bytes);
2265       gcc_assert (mask & (1 << 29));
2266
2267       last = 29;
2268     }
2269
2270   /* Note, it is possible to have gaps in the register mask.
2271      We ignore this here, and generate a JR anyway.  We will
2272      be popping more registers than is strictly necessary, but
2273      it does save code space.  */
2274
2275   if (TARGET_LONG_CALLS)
2276     {
2277       char name[40];
2278
2279       if (first == last)
2280         sprintf (name, "__return_%s", reg_names [first]);
2281       else
2282         sprintf (name, "__return_%s_%s", reg_names [first], reg_names [last]);
2283
2284       sprintf (buff, "movhi hi(%s), r0, r6\n\tmovea lo(%s), r6, r6\n\tjmp r6",
2285                name, name);
2286     }
2287   else
2288     {
2289       if (first == last)
2290         sprintf (buff, "jr __return_%s", reg_names [first]);
2291       else
2292         sprintf (buff, "jr __return_%s_%s", reg_names [first], reg_names [last]);
2293     }
2294
2295   return buff;
2296 }
2297
2298
2299 /* Construct a JARL instruction to a routine that will perform the equivalent
2300    of the RTL passed as a parameter.  This RTL is a function prologue that
2301    saves some of the registers r20 - r31 onto the stack, and possibly acquires
2302    some stack space as well.  The code has already verified that the RTL
2303    matches these requirements.  */
2304 char *
2305 construct_save_jarl (rtx op)
2306 {
2307   int count = XVECLEN (op, 0);
2308   int stack_bytes;
2309   unsigned long int mask;
2310   unsigned long int first;
2311   unsigned long int last;
2312   int i;
2313   static char buff [100]; /* XXX */
2314
2315   if (count <= (TARGET_LONG_CALLS ? 3 : 2))
2316     {
2317       error ("bogus JARL construction: %d", count);
2318       return NULL;
2319     }
2320
2321   /* Paranoia.  */
2322   gcc_assert (GET_CODE (XVECEXP (op, 0, 0)) == SET);
2323   gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) == PLUS);
2324   gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 0)) == REG);
2325   gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) == CONST_INT);
2326
2327   /* Work out how many bytes to push onto the stack after storing the
2328      registers.  */
2329   stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
2330
2331   /* Each push will put 4 bytes from the stack....  */
2332   stack_bytes += (count - (TARGET_LONG_CALLS ? 4 : 3)) * 4;
2333
2334   /* Make sure that the amount we are popping either 0 or 16 bytes.  */
2335   if (stack_bytes != 0)
2336     {
2337       error ("bad amount of stack space removal: %d", stack_bytes);
2338       return NULL;
2339     }
2340
2341   /* Now compute the bit mask of registers to push.  */
2342   mask = 0;
2343   for (i = 1; i < count - (TARGET_LONG_CALLS ? 3 : 2); i++)
2344     {
2345       rtx vector_element = XVECEXP (op, 0, i);
2346
2347       gcc_assert (GET_CODE (vector_element) == SET);
2348       gcc_assert (GET_CODE (SET_SRC (vector_element)) == REG);
2349       gcc_assert (register_is_ok_for_epilogue (SET_SRC (vector_element),
2350                                                SImode));
2351
2352       mask |= 1 << REGNO (SET_SRC (vector_element));
2353     }
2354
2355   /* Scan for the first register to push.  */
2356   for (first = 0; first < 32; first++)
2357     {
2358       if (mask & (1 << first))
2359         break;
2360     }
2361
2362   gcc_assert (first < 32);
2363
2364   /* Discover the last register to push.  */
2365   if (mask & (1 << LINK_POINTER_REGNUM))
2366     {
2367       last = LINK_POINTER_REGNUM;
2368     }
2369   else
2370     {
2371       gcc_assert (!stack_bytes);
2372       gcc_assert (mask & (1 << 29));
2373
2374       last = 29;
2375     }
2376
2377   /* Note, it is possible to have gaps in the register mask.
2378      We ignore this here, and generate a JARL anyway.  We will
2379      be pushing more registers than is strictly necessary, but
2380      it does save code space.  */
2381
2382   if (TARGET_LONG_CALLS)
2383     {
2384       char name[40];
2385
2386       if (first == last)
2387         sprintf (name, "__save_%s", reg_names [first]);
2388       else
2389         sprintf (name, "__save_%s_%s", reg_names [first], reg_names [last]);
2390
2391       if (TARGET_V850E3V5_UP)
2392         sprintf (buff, "mov hilo(%s), r11\n\tjarl [r11], r10", name);
2393       else
2394         sprintf (buff, "movhi hi(%s), r0, r11\n\tmovea lo(%s), r11, r11\n\tjarl .+4, r10\n\tadd 4, r10\n\tjmp r11",
2395                  name, name);
2396     }
2397   else
2398     {
2399       if (first == last)
2400         sprintf (buff, "jarl __save_%s, r10", reg_names [first]);
2401       else
2402         sprintf (buff, "jarl __save_%s_%s, r10", reg_names [first],
2403                  reg_names [last]);
2404     }
2405
2406   return buff;
2407 }
2408
2409 /* A version of asm_output_aligned_bss() that copes with the special
2410    data areas of the v850.  */
2411 void
2412 v850_output_aligned_bss (FILE * file,
2413                          tree decl,
2414                          const char * name,
2415                          unsigned HOST_WIDE_INT size,
2416                          int align)
2417 {
2418   switch (v850_get_data_area (decl))
2419     {
2420     case DATA_AREA_ZDA:
2421       switch_to_section (zbss_section);
2422       break;
2423
2424     case DATA_AREA_SDA:
2425       switch_to_section (sbss_section);
2426       break;
2427
2428     case DATA_AREA_TDA:
2429       switch_to_section (tdata_section);
2430       break;
2431
2432     default:
2433       switch_to_section (bss_section);
2434       break;
2435     }
2436
2437   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
2438 #ifdef ASM_DECLARE_OBJECT_NAME
2439   last_assemble_variable_decl = decl;
2440   ASM_DECLARE_OBJECT_NAME (file, name, decl);
2441 #else
2442   /* Standard thing is just output label for the object.  */
2443   ASM_OUTPUT_LABEL (file, name);
2444 #endif /* ASM_DECLARE_OBJECT_NAME */
2445   ASM_OUTPUT_SKIP (file, size ? size : 1);
2446 }
2447
2448 /* Called via the macro ASM_OUTPUT_DECL_COMMON */
2449 void
2450 v850_output_common (FILE * file,
2451                     tree decl,
2452                     const char * name,
2453                     int size,
2454                     int align)
2455 {
2456   if (decl == NULL_TREE)
2457     {
2458       fprintf (file, "%s", COMMON_ASM_OP);
2459     }
2460   else
2461     {
2462       switch (v850_get_data_area (decl))
2463         {
2464         case DATA_AREA_ZDA:
2465           fprintf (file, "%s", ZCOMMON_ASM_OP);
2466           break;
2467
2468         case DATA_AREA_SDA:
2469           fprintf (file, "%s", SCOMMON_ASM_OP);
2470           break;
2471
2472         case DATA_AREA_TDA:
2473           fprintf (file, "%s", TCOMMON_ASM_OP);
2474           break;
2475
2476         default:
2477           fprintf (file, "%s", COMMON_ASM_OP);
2478           break;
2479         }
2480     }
2481
2482   assemble_name (file, name);
2483   fprintf (file, ",%u,%u\n", size, align / BITS_PER_UNIT);
2484 }
2485
2486 /* Called via the macro ASM_OUTPUT_DECL_LOCAL */
2487 void
2488 v850_output_local (FILE * file,
2489                    tree decl,
2490                    const char * name,
2491                    int size,
2492                    int align)
2493 {
2494   fprintf (file, "%s", LOCAL_ASM_OP);
2495   assemble_name (file, name);
2496   fprintf (file, "\n");
2497
2498   ASM_OUTPUT_ALIGNED_DECL_COMMON (file, decl, name, size, align);
2499 }
2500
2501 /* Add data area to the given declaration if a ghs data area pragma is
2502    currently in effect (#pragma ghs startXXX/endXXX).  */
2503 static void
2504 v850_insert_attributes (tree decl, tree * attr_ptr ATTRIBUTE_UNUSED )
2505 {
2506   if (data_area_stack
2507       && data_area_stack->data_area
2508       && current_function_decl == NULL_TREE
2509       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == CONST_DECL)
2510       && v850_get_data_area (decl) == DATA_AREA_NORMAL)
2511     v850_set_data_area (decl, data_area_stack->data_area);
2512
2513   /* Initialize the default names of the v850 specific sections,
2514      if this has not been done before.  */
2515
2516   if (GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA] == NULL)
2517     {
2518       GHS_default_section_names [(int) GHS_SECTION_KIND_SDATA]
2519         = ".sdata";
2520
2521       GHS_default_section_names [(int) GHS_SECTION_KIND_ROSDATA]
2522         = ".rosdata";
2523
2524       GHS_default_section_names [(int) GHS_SECTION_KIND_TDATA]
2525         = ".tdata";
2526
2527       GHS_default_section_names [(int) GHS_SECTION_KIND_ZDATA]
2528         = ".zdata";
2529
2530       GHS_default_section_names [(int) GHS_SECTION_KIND_ROZDATA]
2531         = ".rozdata";
2532     }
2533
2534   if (current_function_decl == NULL_TREE
2535       && (TREE_CODE (decl) == VAR_DECL
2536           || TREE_CODE (decl) == CONST_DECL
2537           || TREE_CODE (decl) == FUNCTION_DECL)
2538       && (!DECL_EXTERNAL (decl) || DECL_INITIAL (decl))
2539       && !DECL_SECTION_NAME (decl))
2540     {
2541       enum GHS_section_kind kind = GHS_SECTION_KIND_DEFAULT;
2542       const char * chosen_section;
2543
2544       if (TREE_CODE (decl) == FUNCTION_DECL)
2545         kind = GHS_SECTION_KIND_TEXT;
2546       else
2547         {
2548           /* First choose a section kind based on the data area of the decl.  */
2549           switch (v850_get_data_area (decl))
2550             {
2551             default:
2552               gcc_unreachable ();
2553
2554             case DATA_AREA_SDA:
2555               kind = ((TREE_READONLY (decl))
2556                       ? GHS_SECTION_KIND_ROSDATA
2557                       : GHS_SECTION_KIND_SDATA);
2558               break;
2559
2560             case DATA_AREA_TDA:
2561               kind = GHS_SECTION_KIND_TDATA;
2562               break;
2563
2564             case DATA_AREA_ZDA:
2565               kind = ((TREE_READONLY (decl))
2566                       ? GHS_SECTION_KIND_ROZDATA
2567                       : GHS_SECTION_KIND_ZDATA);
2568               break;
2569
2570             case DATA_AREA_NORMAL:               /* default data area */
2571               if (TREE_READONLY (decl))
2572                 kind = GHS_SECTION_KIND_RODATA;
2573               else if (DECL_INITIAL (decl))
2574                 kind = GHS_SECTION_KIND_DATA;
2575               else
2576                 kind = GHS_SECTION_KIND_BSS;
2577             }
2578         }
2579
2580       /* Now, if the section kind has been explicitly renamed,
2581          then attach a section attribute.  */
2582       chosen_section = GHS_current_section_names [(int) kind];
2583
2584       /* Otherwise, if this kind of section needs an explicit section
2585          attribute, then also attach one.  */
2586       if (chosen_section == NULL)
2587         chosen_section = GHS_default_section_names [(int) kind];
2588
2589       if (chosen_section)
2590         {
2591           /* Only set the section name if specified by a pragma, because
2592              otherwise it will force those variables to get allocated storage
2593              in this module, rather than by the linker.  */
2594           set_decl_section_name (decl, chosen_section);
2595         }
2596     }
2597 }
2598
2599 /* Construct a DISPOSE instruction that is the equivalent of
2600    the given RTX.  We have already verified that this should
2601    be possible.  */
2602
2603 char *
2604 construct_dispose_instruction (rtx op)
2605 {
2606   int                count = XVECLEN (op, 0);
2607   int                stack_bytes;
2608   unsigned long int  mask;
2609   int                i;
2610   static char        buff[ 100 ]; /* XXX */
2611   int                use_callt = 0;
2612
2613   if (count <= 2)
2614     {
2615       error ("bogus DISPOSE construction: %d", count);
2616       return NULL;
2617     }
2618
2619   /* Work out how many bytes to pop off the
2620      stack before retrieving registers.  */
2621   gcc_assert (GET_CODE (XVECEXP (op, 0, 1)) == SET);
2622   gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 1))) == PLUS);
2623   gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1)) == CONST_INT);
2624
2625   stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 1)), 1));
2626
2627   /* Each pop will remove 4 bytes from the stack....  */
2628   stack_bytes -= (count - 2) * 4;
2629
2630   /* Make sure that the amount we are popping
2631      will fit into the DISPOSE instruction.  */
2632   if (stack_bytes > 128)
2633     {
2634       error ("too much stack space to dispose of: %d", stack_bytes);
2635       return NULL;
2636     }
2637
2638   /* Now compute the bit mask of registers to push.  */
2639   mask = 0;
2640
2641   for (i = 2; i < count; i++)
2642     {
2643       rtx vector_element = XVECEXP (op, 0, i);
2644
2645       gcc_assert (GET_CODE (vector_element) == SET);
2646       gcc_assert (GET_CODE (SET_DEST (vector_element)) == REG);
2647       gcc_assert (register_is_ok_for_epilogue (SET_DEST (vector_element),
2648                                                SImode));
2649
2650       if (REGNO (SET_DEST (vector_element)) == 2)
2651         use_callt = 1;
2652       else
2653         mask |= 1 << REGNO (SET_DEST (vector_element));
2654     }
2655
2656   if (! TARGET_DISABLE_CALLT
2657       && (use_callt || stack_bytes == 0))
2658     {
2659       if (use_callt)
2660         {
2661           sprintf (buff, "callt ctoff(__callt_return_r2_r%d)", (mask & (1 << 31)) ? 31 : 29);
2662           return buff;
2663         }
2664       else
2665         {
2666           for (i = 20; i < 32; i++)
2667             if (mask & (1 << i))
2668               break;
2669
2670           if (i == 31)
2671             sprintf (buff, "callt ctoff(__callt_return_r31c)");
2672           else
2673             sprintf (buff, "callt ctoff(__callt_return_r%d_r%s)",
2674                      i, (mask & (1 << 31)) ? "31c" : "29");
2675         }
2676     }
2677   else
2678     {
2679       static char        regs [100]; /* XXX */
2680       int                done_one;
2681
2682       /* Generate the DISPOSE instruction.  Note we could just issue the
2683          bit mask as a number as the assembler can cope with this, but for
2684          the sake of our readers we turn it into a textual description.  */
2685       regs[0] = 0;
2686       done_one = 0;
2687
2688       for (i = 20; i < 32; i++)
2689         {
2690           if (mask & (1 << i))
2691             {
2692               int first;
2693
2694               if (done_one)
2695                 strcat (regs, ", ");
2696               else
2697                 done_one = 1;
2698
2699               first = i;
2700               strcat (regs, reg_names[ first ]);
2701
2702               for (i++; i < 32; i++)
2703                 if ((mask & (1 << i)) == 0)
2704                   break;
2705
2706               if (i > first + 1)
2707                 {
2708                   strcat (regs, " - ");
2709                   strcat (regs, reg_names[ i - 1 ] );
2710                 }
2711             }
2712         }
2713
2714       sprintf (buff, "dispose %d {%s}, r31", stack_bytes / 4, regs);
2715     }
2716
2717   return buff;
2718 }
2719
2720 /* Construct a PREPARE instruction that is the equivalent of
2721    the given RTL.  We have already verified that this should
2722    be possible.  */
2723
2724 char *
2725 construct_prepare_instruction (rtx op)
2726 {
2727   int                count;
2728   int                stack_bytes;
2729   unsigned long int  mask;
2730   int                i;
2731   static char        buff[ 100 ]; /* XXX */
2732   int                use_callt = 0;
2733
2734   if (XVECLEN (op, 0) <= 1)
2735     {
2736       error ("bogus PREPEARE construction: %d", XVECLEN (op, 0));
2737       return NULL;
2738     }
2739
2740   /* Work out how many bytes to push onto
2741      the stack after storing the registers.  */
2742   gcc_assert (GET_CODE (XVECEXP (op, 0, 0)) == SET);
2743   gcc_assert (GET_CODE (SET_SRC (XVECEXP (op, 0, 0))) == PLUS);
2744   gcc_assert (GET_CODE (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1)) == CONST_INT);
2745
2746   stack_bytes = INTVAL (XEXP (SET_SRC (XVECEXP (op, 0, 0)), 1));
2747
2748
2749   /* Make sure that the amount we are popping
2750      will fit into the DISPOSE instruction.  */
2751   if (stack_bytes < -128)
2752     {
2753       error ("too much stack space to prepare: %d", stack_bytes);
2754       return NULL;
2755     }
2756
2757   /* Now compute the bit mask of registers to push.  */
2758   count = 0;
2759   mask = 0;
2760   for (i = 1; i < XVECLEN (op, 0); i++)
2761     {
2762       rtx vector_element = XVECEXP (op, 0, i);
2763
2764       if (GET_CODE (vector_element) == CLOBBER)
2765         continue;
2766
2767       gcc_assert (GET_CODE (vector_element) == SET);
2768       gcc_assert (GET_CODE (SET_SRC (vector_element)) == REG);
2769       gcc_assert (register_is_ok_for_epilogue (SET_SRC (vector_element),
2770                                                SImode));
2771
2772       if (REGNO (SET_SRC (vector_element)) == 2)
2773         use_callt = 1;
2774       else
2775         mask |= 1 << REGNO (SET_SRC (vector_element));
2776       count++;
2777     }
2778
2779   stack_bytes += count * 4;
2780
2781   if ((! TARGET_DISABLE_CALLT)
2782       && (use_callt || stack_bytes == 0))
2783     {
2784       if (use_callt)
2785         {
2786           sprintf (buff, "callt ctoff(__callt_save_r2_r%d)", (mask & (1 << 31)) ? 31 : 29 );
2787           return buff;
2788         }
2789
2790       for (i = 20; i < 32; i++)
2791         if (mask & (1 << i))
2792           break;
2793
2794       if (i == 31)
2795         sprintf (buff, "callt ctoff(__callt_save_r31c)");
2796       else
2797         sprintf (buff, "callt ctoff(__callt_save_r%d_r%s)",
2798                  i, (mask & (1 << 31)) ? "31c" : "29");
2799     }
2800   else
2801     {
2802       static char        regs [100]; /* XXX */
2803       int                done_one;
2804
2805
2806       /* Generate the PREPARE instruction.  Note we could just issue the
2807          bit mask as a number as the assembler can cope with this, but for
2808          the sake of our readers we turn it into a textual description.  */
2809       regs[0] = 0;
2810       done_one = 0;
2811
2812       for (i = 20; i < 32; i++)
2813         {
2814           if (mask & (1 << i))
2815             {
2816               int first;
2817
2818               if (done_one)
2819                 strcat (regs, ", ");
2820               else
2821                 done_one = 1;
2822
2823               first = i;
2824               strcat (regs, reg_names[ first ]);
2825
2826               for (i++; i < 32; i++)
2827                 if ((mask & (1 << i)) == 0)
2828                   break;
2829
2830               if (i > first + 1)
2831                 {
2832                   strcat (regs, " - ");
2833                   strcat (regs, reg_names[ i - 1 ] );
2834                 }
2835             }
2836         }
2837
2838       sprintf (buff, "prepare {%s}, %d", regs, (- stack_bytes) / 4);
2839     }
2840
2841   return buff;
2842 }
2843
2844 /* Return an RTX indicating where the return address to the
2845    calling function can be found.  */
2846
2847 rtx
2848 v850_return_addr (int count)
2849 {
2850   if (count != 0)
2851     return const0_rtx;
2852
2853   return get_hard_reg_initial_val (Pmode, LINK_POINTER_REGNUM);
2854 }
2855 \f
2856 /* Implement TARGET_ASM_INIT_SECTIONS.  */
2857
2858 static void
2859 v850_asm_init_sections (void)
2860 {
2861   rosdata_section
2862     = get_unnamed_section (0, output_section_asm_op,
2863                            "\t.section .rosdata,\"a\"");
2864
2865   rozdata_section
2866     = get_unnamed_section (0, output_section_asm_op,
2867                            "\t.section .rozdata,\"a\"");
2868
2869   tdata_section
2870     = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
2871                            "\t.section .tdata,\"aw\"");
2872
2873   zdata_section
2874     = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
2875                            "\t.section .zdata,\"aw\"");
2876
2877   zbss_section
2878     = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
2879                            output_section_asm_op,
2880                            "\t.section .zbss,\"aw\"");
2881 }
2882
2883 static section *
2884 v850_select_section (tree exp,
2885                      int reloc ATTRIBUTE_UNUSED,
2886                      unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
2887 {
2888   if (TREE_CODE (exp) == VAR_DECL)
2889     {
2890       int is_const;
2891       if (!TREE_READONLY (exp)
2892           || TREE_SIDE_EFFECTS (exp)
2893           || !DECL_INITIAL (exp)
2894           || (DECL_INITIAL (exp) != error_mark_node
2895               && !TREE_CONSTANT (DECL_INITIAL (exp))))
2896         is_const = FALSE;
2897       else
2898         is_const = TRUE;
2899
2900       switch (v850_get_data_area (exp))
2901         {
2902         case DATA_AREA_ZDA:
2903           return is_const ? rozdata_section : zdata_section;
2904
2905         case DATA_AREA_TDA:
2906           return tdata_section;
2907
2908         case DATA_AREA_SDA:
2909           return is_const ? rosdata_section : sdata_section;
2910
2911         default:
2912           return is_const ? readonly_data_section : data_section;
2913         }
2914     }
2915   return readonly_data_section;
2916 }
2917 \f
2918 /* Worker function for TARGET_FUNCTION_VALUE_REGNO_P.  */
2919
2920 static bool
2921 v850_function_value_regno_p (const unsigned int regno)
2922 {
2923   return (regno == RV_REGNUM);
2924 }
2925
2926 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
2927
2928 static bool
2929 v850_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
2930 {
2931   /* Return values > 8 bytes in length in memory.  */
2932   return int_size_in_bytes (type) > 8
2933     || TYPE_MODE (type) == BLKmode
2934     /* With the rh850 ABI return all aggregates in memory.  */
2935     || ((! TARGET_GCC_ABI) && AGGREGATE_TYPE_P (type))
2936     ;
2937 }
2938
2939 /* Worker function for TARGET_FUNCTION_VALUE.  */
2940
2941 static rtx
2942 v850_function_value (const_tree valtype,
2943                     const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
2944                     bool outgoing ATTRIBUTE_UNUSED)
2945 {
2946   return gen_rtx_REG (TYPE_MODE (valtype), RV_REGNUM);
2947 }
2948
2949 /* Implement TARGET_LIBCALL_VALUE.  */
2950
2951 static rtx
2952 v850_libcall_value (machine_mode mode,
2953                     const_rtx func ATTRIBUTE_UNUSED)
2954 {
2955   return gen_rtx_REG (mode, RV_REGNUM);
2956 }
2957
2958 \f
2959 /* Worker function for TARGET_CAN_ELIMINATE.  */
2960
2961 static bool
2962 v850_can_eliminate (const int from ATTRIBUTE_UNUSED, const int to)
2963 {
2964   return (to == STACK_POINTER_REGNUM ? ! frame_pointer_needed : true);
2965 }
2966
2967 /* Worker function for TARGET_CONDITIONAL_REGISTER_USAGE.
2968
2969    If TARGET_APP_REGS is not defined then add r2 and r5 to
2970    the pool of fixed registers. See PR 14505.  */
2971
2972 static void
2973 v850_conditional_register_usage (void)
2974 {
2975   if (TARGET_APP_REGS)
2976     {
2977      fixed_regs[2] = 0;  call_used_regs[2] = 0;
2978      fixed_regs[5] = 0;  call_used_regs[5] = 1;
2979     }
2980 }
2981 \f
2982 /* Worker function for TARGET_ASM_TRAMPOLINE_TEMPLATE.  */
2983
2984 static void
2985 v850_asm_trampoline_template (FILE *f)
2986 {
2987   fprintf (f, "\tjarl .+4,r12\n");
2988   fprintf (f, "\tld.w 12[r12],r20\n");
2989   fprintf (f, "\tld.w 16[r12],r12\n");
2990   fprintf (f, "\tjmp [r12]\n");
2991   fprintf (f, "\tnop\n");
2992   fprintf (f, "\t.long 0\n");
2993   fprintf (f, "\t.long 0\n");
2994 }
2995
2996 /* Worker function for TARGET_TRAMPOLINE_INIT.  */
2997
2998 static void
2999 v850_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
3000 {
3001   rtx mem, fnaddr = XEXP (DECL_RTL (fndecl), 0);
3002
3003   emit_block_move (m_tramp, assemble_trampoline_template (),
3004                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
3005
3006   mem = adjust_address (m_tramp, SImode, 16);
3007   emit_move_insn (mem, chain_value);
3008   mem = adjust_address (m_tramp, SImode, 20);
3009   emit_move_insn (mem, fnaddr);
3010 }
3011
3012 static int
3013 v850_issue_rate (void)
3014 {
3015   return (TARGET_V850E2_UP ? 2 : 1);
3016 }
3017
3018 /* Implement TARGET_LEGITIMATE_CONSTANT_P.  */
3019
3020 static bool
3021 v850_legitimate_constant_p (machine_mode mode ATTRIBUTE_UNUSED, rtx x)
3022 {
3023   return (GET_CODE (x) == CONST_DOUBLE
3024           || !(GET_CODE (x) == CONST
3025                && GET_CODE (XEXP (x, 0)) == PLUS
3026                && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF
3027                && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3028                && !CONST_OK_FOR_K (INTVAL (XEXP (XEXP (x, 0), 1)))));
3029 }
3030
3031 /* Helper function for `v850_legitimate_address_p'.  */
3032
3033 static bool
3034 v850_reg_ok_for_base_p (const_rtx reg, bool strict_p)
3035 {
3036   if (strict_p)
3037   {
3038     return REGNO_OK_FOR_BASE_P (REGNO (reg));
3039   } else {
3040     return true;
3041   }
3042 }
3043
3044 /* Accept either REG or SUBREG where a register is valid.  */
3045
3046 static bool
3047 v850_rtx_ok_for_base_p (const_rtx x, bool strict_p)
3048 {
3049   return ((REG_P (x) && v850_reg_ok_for_base_p  (x, strict_p))
3050           || (SUBREG_P (x) && REG_P (SUBREG_REG (x))
3051               && v850_reg_ok_for_base_p (SUBREG_REG (x), strict_p)));
3052 }
3053
3054 /* Implement TARGET_LEGITIMATE_ADDRESS_P.  */
3055
3056 static bool
3057 v850_legitimate_address_p (machine_mode mode, rtx x, bool strict_p,
3058                            addr_space_t as ATTRIBUTE_UNUSED)
3059 {
3060   gcc_assert (ADDR_SPACE_GENERIC_P (as));
3061
3062   if (v850_rtx_ok_for_base_p (x, strict_p))
3063     return true;
3064   if (CONSTANT_ADDRESS_P (x)
3065       && (mode == QImode || INTVAL (x) % 2 == 0)
3066       && (GET_MODE_SIZE (mode) <= 4 || INTVAL (x) % 4 == 0))
3067     return true;
3068   if (GET_CODE (x) == LO_SUM
3069       && REG_P (XEXP (x, 0))
3070       && v850_reg_ok_for_base_p (XEXP (x, 0), strict_p)
3071       && CONSTANT_P (XEXP (x, 1))
3072       && (!CONST_INT_P (XEXP (x, 1))
3073           || ((mode == QImode || INTVAL (XEXP (x, 1)) % 2 == 0)
3074               && constraint_satisfied_p (XEXP (x, 1), CONSTRAINT_K)))
3075       && GET_MODE_SIZE (mode) <= GET_MODE_SIZE (word_mode))
3076     return true;
3077   if (special_symbolref_operand (x, mode)
3078       && (GET_MODE_SIZE (mode) <= GET_MODE_SIZE (word_mode)))
3079     return true;
3080   if (GET_CODE (x) == PLUS
3081       && v850_rtx_ok_for_base_p (XEXP (x, 0), strict_p)
3082       && (constraint_satisfied_p (XEXP (x, 1), CONSTRAINT_K)
3083           || (TARGET_V850E2V3_UP
3084               && (mode == SImode || mode == HImode || mode == QImode)
3085               && constraint_satisfied_p (XEXP (x, 1), CONSTRAINT_W)))
3086       && ((mode == QImode || INTVAL (XEXP (x, 1)) % 2 == 0)
3087            && CONST_OK_FOR_K (INTVAL (XEXP (x, 1))
3088                               + (GET_MODE_NUNITS (mode) * UNITS_PER_WORD))))
3089     return true;
3090
3091   return false;
3092 }
3093
3094 static int
3095 v850_memory_move_cost (machine_mode mode,
3096                        reg_class_t reg_class ATTRIBUTE_UNUSED,
3097                        bool in)
3098 {
3099   switch (GET_MODE_SIZE (mode))
3100     {
3101     case 0:
3102       return in ? 24 : 8;
3103     case 1:
3104     case 2:
3105     case 3:
3106     case 4:
3107       return in ? 6 : 2;
3108     default:
3109       return (GET_MODE_SIZE (mode) / 2) * (in ? 3 : 1);
3110     }
3111 }
3112
3113 int
3114 v850_adjust_insn_length (rtx_insn *insn, int length)
3115 {
3116   if (TARGET_V850E3V5_UP)
3117     {
3118       if (CALL_P (insn))
3119         {
3120           if (TARGET_LONG_CALLS)
3121             {
3122               /* call_internal_long, call_value_internal_long.  */
3123               if (length == 8)
3124                 length = 4;
3125               if (length == 16)
3126                 length = 10;
3127             }
3128           else
3129             {
3130               /* call_internal_short, call_value_internal_short.  */
3131               if (length == 8)
3132                 length = 4;
3133             }
3134         }
3135     }
3136   return length;
3137 }
3138 \f
3139 /* V850 specific attributes.  */
3140
3141 static const struct attribute_spec v850_attribute_table[] =
3142 {
3143   /* { name, min_len, max_len, decl_req, type_req, fn_type_req,
3144        affects_type_identity, handler, exclude } */
3145   { "interrupt_handler", 0, 0, true,  false, false, false,
3146     v850_handle_interrupt_attribute, NULL },
3147   { "interrupt",         0, 0, true,  false, false, false,
3148     v850_handle_interrupt_attribute, NULL },
3149   { "sda",               0, 0, true,  false, false, false,
3150     v850_handle_data_area_attribute, NULL },
3151   { "tda",               0, 0, true,  false, false, false,
3152     v850_handle_data_area_attribute, NULL },
3153   { "zda",               0, 0, true,  false, false, false,
3154     v850_handle_data_area_attribute, NULL },
3155   { NULL,                0, 0, false, false, false, false, NULL, NULL }
3156 };
3157 \f
3158 static void
3159 v850_option_override (void)
3160 {
3161   if (flag_exceptions || flag_non_call_exceptions)
3162     flag_omit_frame_pointer = 0;
3163
3164   /* The RH850 ABI does not (currently) support the use of the CALLT instruction.  */
3165   if (! TARGET_GCC_ABI)
3166     target_flags |= MASK_DISABLE_CALLT;
3167 }
3168 \f
3169 const char *
3170 v850_gen_movdi (rtx * operands)
3171 {
3172   if (REG_P (operands[0]))
3173     {
3174       if (REG_P (operands[1]))
3175         {
3176           if (REGNO (operands[0]) == (REGNO (operands[1]) - 1))
3177             return "mov %1, %0; mov %R1, %R0";
3178
3179           return "mov %R1, %R0; mov %1, %0";
3180         }
3181
3182       if (MEM_P (operands[1]))
3183         {
3184           if (REGNO (operands[0]) & 1)
3185             /* Use two load word instructions to synthesise a load double.  */
3186             return "ld.w %1, %0 ; ld.w %R1, %R0" ;
3187
3188           return "ld.dw %1, %0";
3189         }
3190
3191       return "mov %1, %0; mov %R1, %R0";
3192     }
3193
3194   gcc_assert (REG_P (operands[1]));
3195
3196   if (REGNO (operands[1]) & 1)
3197     /* Use two store word instructions to synthesise a store double.  */
3198     return "st.w %1, %0 ; st.w %R1, %R0 ";
3199
3200   return "st.dw %1, %0";
3201 }
3202
3203 /* Implement TARGET_HARD_REGNO_MODE_OK.  */
3204
3205 static bool
3206 v850_hard_regno_mode_ok (unsigned int regno, machine_mode mode)
3207 {
3208   return GET_MODE_SIZE (mode) <= 4 || ((regno & 1) == 0 && regno != 0);
3209 }
3210
3211 /* Implement TARGET_MODES_TIEABLE_P.  */
3212
3213 static bool
3214 v850_modes_tieable_p (machine_mode mode1, machine_mode mode2)
3215 {
3216   return (mode1 == mode2
3217           || (GET_MODE_SIZE (mode1) <= 4 && GET_MODE_SIZE (mode2) <= 4));
3218 }
3219 \f
3220 /* Initialize the GCC target structure.  */
3221
3222 #undef  TARGET_OPTION_OVERRIDE
3223 #define TARGET_OPTION_OVERRIDE          v850_option_override
3224
3225 #undef  TARGET_MEMORY_MOVE_COST
3226 #define TARGET_MEMORY_MOVE_COST         v850_memory_move_cost
3227
3228 #undef  TARGET_ASM_ALIGNED_HI_OP
3229 #define TARGET_ASM_ALIGNED_HI_OP "\t.hword\t"
3230
3231 #undef  TARGET_PRINT_OPERAND
3232 #define TARGET_PRINT_OPERAND            v850_print_operand
3233 #undef  TARGET_PRINT_OPERAND_ADDRESS
3234 #define TARGET_PRINT_OPERAND_ADDRESS            v850_print_operand_address
3235 #undef  TARGET_PRINT_OPERAND_PUNCT_VALID_P
3236 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P      v850_print_operand_punct_valid_p
3237
3238 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
3239 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA v850_output_addr_const_extra
3240
3241 #undef  TARGET_ATTRIBUTE_TABLE
3242 #define TARGET_ATTRIBUTE_TABLE v850_attribute_table
3243
3244 #undef  TARGET_INSERT_ATTRIBUTES
3245 #define TARGET_INSERT_ATTRIBUTES v850_insert_attributes
3246
3247 #undef  TARGET_ASM_SELECT_SECTION
3248 #define TARGET_ASM_SELECT_SECTION  v850_select_section
3249
3250 /* The assembler supports switchable .bss sections, but
3251    v850_select_section doesn't yet make use of them.  */
3252 #undef  TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
3253 #define TARGET_HAVE_SWITCHABLE_BSS_SECTIONS false
3254
3255 #undef  TARGET_ENCODE_SECTION_INFO
3256 #define TARGET_ENCODE_SECTION_INFO v850_encode_section_info
3257
3258 #undef  TARGET_ASM_FILE_START_FILE_DIRECTIVE
3259 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
3260
3261 #undef  TARGET_RTX_COSTS
3262 #define TARGET_RTX_COSTS v850_rtx_costs
3263
3264 #undef  TARGET_ADDRESS_COST
3265 #define TARGET_ADDRESS_COST hook_int_rtx_mode_as_bool_0
3266
3267 #undef  TARGET_MACHINE_DEPENDENT_REORG
3268 #define TARGET_MACHINE_DEPENDENT_REORG v850_reorg
3269
3270 #undef  TARGET_SCHED_ISSUE_RATE
3271 #define TARGET_SCHED_ISSUE_RATE v850_issue_rate
3272
3273 #undef  TARGET_FUNCTION_VALUE_REGNO_P
3274 #define TARGET_FUNCTION_VALUE_REGNO_P v850_function_value_regno_p
3275 #undef  TARGET_FUNCTION_VALUE
3276 #define TARGET_FUNCTION_VALUE v850_function_value
3277 #undef  TARGET_LIBCALL_VALUE
3278 #define TARGET_LIBCALL_VALUE v850_libcall_value
3279
3280 #undef  TARGET_PROMOTE_PROTOTYPES
3281 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
3282
3283 #undef  TARGET_RETURN_IN_MEMORY
3284 #define TARGET_RETURN_IN_MEMORY v850_return_in_memory
3285
3286 #undef  TARGET_PASS_BY_REFERENCE
3287 #define TARGET_PASS_BY_REFERENCE v850_pass_by_reference
3288
3289 #undef  TARGET_CALLEE_COPIES
3290 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
3291
3292 #undef  TARGET_ARG_PARTIAL_BYTES
3293 #define TARGET_ARG_PARTIAL_BYTES v850_arg_partial_bytes
3294
3295 #undef  TARGET_FUNCTION_ARG
3296 #define TARGET_FUNCTION_ARG v850_function_arg
3297
3298 #undef  TARGET_FUNCTION_ARG_ADVANCE
3299 #define TARGET_FUNCTION_ARG_ADVANCE v850_function_arg_advance
3300
3301 #undef  TARGET_CAN_ELIMINATE
3302 #define TARGET_CAN_ELIMINATE v850_can_eliminate
3303
3304 #undef  TARGET_CONDITIONAL_REGISTER_USAGE
3305 #define TARGET_CONDITIONAL_REGISTER_USAGE v850_conditional_register_usage
3306
3307 #undef  TARGET_ASM_TRAMPOLINE_TEMPLATE
3308 #define TARGET_ASM_TRAMPOLINE_TEMPLATE v850_asm_trampoline_template
3309 #undef  TARGET_TRAMPOLINE_INIT
3310 #define TARGET_TRAMPOLINE_INIT v850_trampoline_init
3311
3312 #undef  TARGET_LEGITIMATE_CONSTANT_P
3313 #define TARGET_LEGITIMATE_CONSTANT_P v850_legitimate_constant_p
3314
3315 #undef  TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
3316 #define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P v850_legitimate_address_p
3317
3318 #undef  TARGET_CAN_USE_DOLOOP_P
3319 #define TARGET_CAN_USE_DOLOOP_P can_use_doloop_if_innermost
3320
3321 #undef  TARGET_HARD_REGNO_MODE_OK
3322 #define TARGET_HARD_REGNO_MODE_OK v850_hard_regno_mode_ok
3323
3324 #undef  TARGET_MODES_TIEABLE_P
3325 #define TARGET_MODES_TIEABLE_P v850_modes_tieable_p
3326
3327 #undef TARGET_FLAGS_REGNUM
3328 #define TARGET_FLAGS_REGNUM 32
3329
3330 #undef  TARGET_HAVE_SPECULATION_SAFE_VALUE
3331 #define TARGET_HAVE_SPECULATION_SAFE_VALUE speculation_safe_value_not_needed
3332
3333 struct gcc_target targetm = TARGET_INITIALIZER;
3334
3335 #include "gt-v850.h"