gcc/config/v850/v850.c

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