gcc/config/xtensa/xtensa.c

   1 /* Subroutines for insn-output.c for Tensilica's Xtensa architecture.
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4    Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 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 "rtl.h"
  27 #include "regs.h"
  28 #include "hard-reg-set.h"
  29 #include "basic-block.h"
  30 #include "insn-config.h"
  31 #include "conditions.h"
  32 #include "insn-flags.h"
  33 #include "insn-attr.h"
  34 #include "insn-codes.h"
  35 #include "recog.h"
  36 #include "output.h"
  37 #include "tree.h"
  38 #include "expr.h"
  39 #include "flags.h"
  40 #include "reload.h"
  41 #include "tm_p.h"
  42 #include "function.h"
  43 #include "diagnostic-core.h"
  44 #include "toplev.h"
  45 #include "optabs.h"
  46 #include "libfuncs.h"
  47 #include "ggc.h"
  48 #include "target.h"
  49 #include "target-def.h"
  50 #include "langhooks.h"
  51 #include "gimple.h"
  52 #include "df.h"
  53
  54
  55 /* Enumeration for all of the relational tests, so that we can build
  56    arrays indexed by the test type, and not worry about the order
  57    of EQ, NE, etc.  */
  58
  59 enum internal_test
  60 {
  61   ITEST_EQ,
  62   ITEST_NE,
  63   ITEST_GT,
  64   ITEST_GE,
  65   ITEST_LT,
  66   ITEST_LE,
  67   ITEST_GTU,
  68   ITEST_GEU,
  69   ITEST_LTU,
  70   ITEST_LEU,
  71   ITEST_MAX
  72 };
  73
  74 /* Array giving truth value on whether or not a given hard register
  75    can support a given mode.  */
  76 char xtensa_hard_regno_mode_ok[(int) MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
  77
  78 /* Current frame size calculated by compute_frame_size.  */
  79 unsigned xtensa_current_frame_size;
  80
  81 /* Largest block move to handle in-line.  */
  82 #define LARGEST_MOVE_RATIO 15
  83
  84 /* Define the structure for the machine field in struct function.  */
  85 struct GTY(()) machine_function
  86 {
  87   int accesses_prev_frame;
  88   bool need_a7_copy;
  89   bool vararg_a7;
  90   rtx vararg_a7_copy;
  91   rtx set_frame_ptr_insn;
  92 };
  93
  94 /* Vector, indexed by hard register number, which contains 1 for a
  95    register that is allowable in a candidate for leaf function
  96    treatment.  */
  97
  98 const char xtensa_leaf_regs[FIRST_PSEUDO_REGISTER] =
  99 {
 100   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 101   1, 1, 1,
 102   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 103   1
 104 };
 105
 106 /* Map hard register number to register class */
 107 const enum reg_class xtensa_regno_to_class[FIRST_PSEUDO_REGISTER] =
 108 {
 109   RL_REGS,      SP_REG,         RL_REGS,        RL_REGS,
 110   RL_REGS,      RL_REGS,        RL_REGS,        GR_REGS,
 111   RL_REGS,      RL_REGS,        RL_REGS,        RL_REGS,
 112   RL_REGS,      RL_REGS,        RL_REGS,        RL_REGS,
 113   AR_REGS,      AR_REGS,        BR_REGS,
 114   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 115   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 116   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 117   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
 118   ACC_REG,
 119 };
 120
 121 static void xtensa_option_override (void);
 122 static enum internal_test map_test_to_internal_test (enum rtx_code);
 123 static rtx gen_int_relational (enum rtx_code, rtx, rtx, int *);
 124 static rtx gen_float_relational (enum rtx_code, rtx, rtx);
 125 static rtx gen_conditional_move (enum rtx_code, enum machine_mode, rtx, rtx);
 126 static rtx fixup_subreg_mem (rtx);
 127 static struct machine_function * xtensa_init_machine_status (void);
 128 static rtx xtensa_legitimize_tls_address (rtx);
 129 static rtx xtensa_legitimize_address (rtx, rtx, enum machine_mode);
 130 static bool xtensa_return_in_msb (const_tree);
 131 static void printx (FILE *, signed int);
 132 static void xtensa_function_epilogue (FILE *, HOST_WIDE_INT);
 133 static rtx xtensa_builtin_saveregs (void);
 134 static bool xtensa_legitimate_address_p (enum machine_mode, rtx, bool);
 135 static unsigned int xtensa_multibss_section_type_flags (tree, const char *,
 136                                                         int) ATTRIBUTE_UNUSED;
 137 static section *xtensa_select_rtx_section (enum machine_mode, rtx,
 138                                            unsigned HOST_WIDE_INT);
 139 static bool xtensa_rtx_costs (rtx, int, int, int *, bool);
 140 static tree xtensa_build_builtin_va_list (void);
 141 static bool xtensa_return_in_memory (const_tree, const_tree);
 142 static tree xtensa_gimplify_va_arg_expr (tree, tree, gimple_seq *,
 143                                          gimple_seq *);
 144 static void xtensa_function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode,
 145                                          const_tree, bool);
 146 static rtx xtensa_function_arg (CUMULATIVE_ARGS *, enum machine_mode,
 147                                 const_tree, bool);
 148 static rtx xtensa_function_incoming_arg (CUMULATIVE_ARGS *,
 149                                          enum machine_mode, const_tree, bool);
 150 static rtx xtensa_function_value (const_tree, const_tree, bool);
 151 static void xtensa_init_builtins (void);
 152 static tree xtensa_fold_builtin (tree, int, tree *, bool);
 153 static rtx xtensa_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 154 static void xtensa_va_start (tree, rtx);
 155 static bool xtensa_frame_pointer_required (void);
 156 static rtx xtensa_static_chain (const_tree, bool);
 157 static void xtensa_asm_trampoline_template (FILE *);
 158 static void xtensa_trampoline_init (rtx, tree, rtx);
 159
 160 static const int reg_nonleaf_alloc_order[FIRST_PSEUDO_REGISTER] =
 161   REG_ALLOC_ORDER;
 162
 163 /* Implement TARGET_OPTION_OPTIMIZATION_TABLE.  */
 164
 165 static const struct default_options xtensa_option_optimization_table[] =
 166   {
 167     { OPT_LEVELS_1_PLUS, OPT_fomit_frame_pointer, NULL, 1 },
 168     /* Reordering blocks for Xtensa is not a good idea unless the
 169        compiler understands the range of conditional branches.
 170        Currently all branch relaxation for Xtensa is handled in the
 171        assembler, so GCC cannot do a good job of reordering blocks.
 172        Do not enable reordering unless it is explicitly requested.  */
 173     { OPT_LEVELS_ALL, OPT_freorder_blocks, NULL, 0 },
 174     { OPT_LEVELS_NONE, 0, NULL, 0 }
 175   };
 176 \f
 177
 178 /* This macro generates the assembly code for function exit,
 179    on machines that need it.  If FUNCTION_EPILOGUE is not defined
 180    then individual return instructions are generated for each
 181    return statement.  Args are same as for FUNCTION_PROLOGUE.  */
 182
 183 #undef TARGET_ASM_FUNCTION_EPILOGUE
 184 #define TARGET_ASM_FUNCTION_EPILOGUE xtensa_function_epilogue
 185
 186 /* These hooks specify assembly directives for creating certain kinds
 187    of integer object.  */
 188
 189 #undef TARGET_ASM_ALIGNED_SI_OP
 190 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
 191
 192 #undef TARGET_ASM_SELECT_RTX_SECTION
 193 #define TARGET_ASM_SELECT_RTX_SECTION  xtensa_select_rtx_section
 194
 195 #undef TARGET_DEFAULT_TARGET_FLAGS
 196 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | MASK_FUSED_MADD)
 197
 198 #undef TARGET_LEGITIMIZE_ADDRESS
 199 #define TARGET_LEGITIMIZE_ADDRESS xtensa_legitimize_address
 200
 201 #undef TARGET_RTX_COSTS
 202 #define TARGET_RTX_COSTS xtensa_rtx_costs
 203 #undef TARGET_ADDRESS_COST
 204 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
 205
 206 #undef TARGET_BUILD_BUILTIN_VA_LIST
 207 #define TARGET_BUILD_BUILTIN_VA_LIST xtensa_build_builtin_va_list
 208
 209 #undef TARGET_EXPAND_BUILTIN_VA_START
 210 #define TARGET_EXPAND_BUILTIN_VA_START xtensa_va_start
 211
 212 #undef TARGET_PROMOTE_FUNCTION_MODE
 213 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
 214 #undef TARGET_PROMOTE_PROTOTYPES
 215 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
 216
 217 #undef TARGET_RETURN_IN_MEMORY
 218 #define TARGET_RETURN_IN_MEMORY xtensa_return_in_memory
 219 #undef TARGET_FUNCTION_VALUE
 220 #define TARGET_FUNCTION_VALUE xtensa_function_value
 221 #undef TARGET_SPLIT_COMPLEX_ARG
 222 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
 223 #undef TARGET_MUST_PASS_IN_STACK
 224 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 225 #undef TARGET_FUNCTION_ARG_ADVANCE
 226 #define TARGET_FUNCTION_ARG_ADVANCE xtensa_function_arg_advance
 227 #undef TARGET_FUNCTION_ARG
 228 #define TARGET_FUNCTION_ARG xtensa_function_arg
 229 #undef TARGET_FUNCTION_INCOMING_ARG
 230 #define TARGET_FUNCTION_INCOMING_ARG xtensa_function_incoming_arg
 231
 232 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 233 #define TARGET_EXPAND_BUILTIN_SAVEREGS xtensa_builtin_saveregs
 234 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 235 #define TARGET_GIMPLIFY_VA_ARG_EXPR xtensa_gimplify_va_arg_expr
 236
 237 #undef TARGET_RETURN_IN_MSB
 238 #define TARGET_RETURN_IN_MSB xtensa_return_in_msb
 239
 240 #undef  TARGET_INIT_BUILTINS
 241 #define TARGET_INIT_BUILTINS xtensa_init_builtins
 242 #undef  TARGET_FOLD_BUILTIN
 243 #define TARGET_FOLD_BUILTIN xtensa_fold_builtin
 244 #undef  TARGET_EXPAND_BUILTIN
 245 #define TARGET_EXPAND_BUILTIN xtensa_expand_builtin
 246
 247 #undef TARGET_SECONDARY_RELOAD
 248 #define TARGET_SECONDARY_RELOAD xtensa_secondary_reload
 249
 250 #undef TARGET_HAVE_TLS
 251 #define TARGET_HAVE_TLS (TARGET_THREADPTR && HAVE_AS_TLS)
 252
 253 #undef TARGET_CANNOT_FORCE_CONST_MEM
 254 #define TARGET_CANNOT_FORCE_CONST_MEM xtensa_tls_referenced_p
 255
 256 #undef TARGET_LEGITIMATE_ADDRESS_P
 257 #define TARGET_LEGITIMATE_ADDRESS_P     xtensa_legitimate_address_p
 258
 259 #undef TARGET_FRAME_POINTER_REQUIRED
 260 #define TARGET_FRAME_POINTER_REQUIRED xtensa_frame_pointer_required
 261
 262 #undef TARGET_STATIC_CHAIN
 263 #define TARGET_STATIC_CHAIN xtensa_static_chain
 264 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
 265 #define TARGET_ASM_TRAMPOLINE_TEMPLATE xtensa_asm_trampoline_template
 266 #undef TARGET_TRAMPOLINE_INIT
 267 #define TARGET_TRAMPOLINE_INIT xtensa_trampoline_init
 268
 269 #undef TARGET_OPTION_OVERRIDE
 270 #define TARGET_OPTION_OVERRIDE xtensa_option_override
 271 #undef TARGET_OPTION_OPTIMIZATION_TABLE
 272 #define TARGET_OPTION_OPTIMIZATION_TABLE xtensa_option_optimization_table
 273
 274 struct gcc_target targetm = TARGET_INITIALIZER;
 275
 276 \f
 277 /* Functions to test Xtensa immediate operand validity.  */
 278
 279 bool
 280 xtensa_simm8 (HOST_WIDE_INT v)
 281 {
 282   return v >= -128 && v <= 127;
 283 }
 284
 285
 286 bool
 287 xtensa_simm8x256 (HOST_WIDE_INT v)
 288 {
 289   return (v & 255) == 0 && (v >= -32768 && v <= 32512);
 290 }
 291
 292
 293 bool
 294 xtensa_simm12b (HOST_WIDE_INT v)
 295 {
 296   return v >= -2048 && v <= 2047;
 297 }
 298
 299
 300 static bool
 301 xtensa_uimm8 (HOST_WIDE_INT v)
 302 {
 303   return v >= 0 && v <= 255;
 304 }
 305
 306
 307 static bool
 308 xtensa_uimm8x2 (HOST_WIDE_INT v)
 309 {
 310   return (v & 1) == 0 && (v >= 0 && v <= 510);
 311 }
 312
 313
 314 static bool
 315 xtensa_uimm8x4 (HOST_WIDE_INT v)
 316 {
 317   return (v & 3) == 0 && (v >= 0 && v <= 1020);
 318 }
 319
 320
 321 static bool
 322 xtensa_b4const (HOST_WIDE_INT v)
 323 {
 324   switch (v)
 325     {
 326     case -1:
 327     case 1:
 328     case 2:
 329     case 3:
 330     case 4:
 331     case 5:
 332     case 6:
 333     case 7:
 334     case 8:
 335     case 10:
 336     case 12:
 337     case 16:
 338     case 32:
 339     case 64:
 340     case 128:
 341     case 256:
 342       return true;
 343     }
 344   return false;
 345 }
 346
 347
 348 bool
 349 xtensa_b4const_or_zero (HOST_WIDE_INT v)
 350 {
 351   if (v == 0)
 352     return true;
 353   return xtensa_b4const (v);
 354 }
 355
 356
 357 bool
 358 xtensa_b4constu (HOST_WIDE_INT v)
 359 {
 360   switch (v)
 361     {
 362     case 32768:
 363     case 65536:
 364     case 2:
 365     case 3:
 366     case 4:
 367     case 5:
 368     case 6:
 369     case 7:
 370     case 8:
 371     case 10:
 372     case 12:
 373     case 16:
 374     case 32:
 375     case 64:
 376     case 128:
 377     case 256:
 378       return true;
 379     }
 380   return false;
 381 }
 382
 383
 384 bool
 385 xtensa_mask_immediate (HOST_WIDE_INT v)
 386 {
 387 #define MAX_MASK_SIZE 16
 388   int mask_size;
 389
 390   for (mask_size = 1; mask_size <= MAX_MASK_SIZE; mask_size++)
 391     {
 392       if ((v & 1) == 0)
 393         return false;
 394       v = v >> 1;
 395       if (v == 0)
 396         return true;
 397     }
 398
 399   return false;
 400 }
 401
 402
 403 /* This is just like the standard true_regnum() function except that it
 404    works even when reg_renumber is not initialized.  */
 405
 406 int
 407 xt_true_regnum (rtx x)
 408 {
 409   if (GET_CODE (x) == REG)
 410     {
 411       if (reg_renumber
 412           && REGNO (x) >= FIRST_PSEUDO_REGISTER
 413           && reg_renumber[REGNO (x)] >= 0)
 414         return reg_renumber[REGNO (x)];
 415       return REGNO (x);
 416     }
 417   if (GET_CODE (x) == SUBREG)
 418     {
 419       int base = xt_true_regnum (SUBREG_REG (x));
 420       if (base >= 0 && base < FIRST_PSEUDO_REGISTER)
 421         return base + subreg_regno_offset (REGNO (SUBREG_REG (x)),
 422                                            GET_MODE (SUBREG_REG (x)),
 423                                            SUBREG_BYTE (x), GET_MODE (x));
 424     }
 425   return -1;
 426 }
 427
 428
 429 int
 430 xtensa_valid_move (enum machine_mode mode, rtx *operands)
 431 {
 432   /* Either the destination or source must be a register, and the
 433      MAC16 accumulator doesn't count.  */
 434
 435   if (register_operand (operands[0], mode))
 436     {
 437       int dst_regnum = xt_true_regnum (operands[0]);
 438
 439       /* The stack pointer can only be assigned with a MOVSP opcode.  */
 440       if (dst_regnum == STACK_POINTER_REGNUM)
 441         return (mode == SImode
 442                 && register_operand (operands[1], mode)
 443                 && !ACC_REG_P (xt_true_regnum (operands[1])));
 444
 445       if (!ACC_REG_P (dst_regnum))
 446         return true;
 447     }
 448   if (register_operand (operands[1], mode))
 449     {
 450       int src_regnum = xt_true_regnum (operands[1]);
 451       if (!ACC_REG_P (src_regnum))
 452         return true;
 453     }
 454   return FALSE;
 455 }
 456
 457
 458 int
 459 smalloffset_mem_p (rtx op)
 460 {
 461   if (GET_CODE (op) == MEM)
 462     {
 463       rtx addr = XEXP (op, 0);
 464       if (GET_CODE (addr) == REG)
 465         return BASE_REG_P (addr, 0);
 466       if (GET_CODE (addr) == PLUS)
 467         {
 468           rtx offset = XEXP (addr, 0);
 469           HOST_WIDE_INT val;
 470           if (GET_CODE (offset) != CONST_INT)
 471             offset = XEXP (addr, 1);
 472           if (GET_CODE (offset) != CONST_INT)
 473             return FALSE;
 474
 475           val = INTVAL (offset);
 476           return (val & 3) == 0 && (val >= 0 && val <= 60);
 477         }
 478     }
 479   return FALSE;
 480 }
 481
 482
 483 int
 484 constantpool_address_p (rtx addr)
 485 {
 486   rtx sym = addr;
 487
 488   if (GET_CODE (addr) == CONST)
 489     {
 490       rtx offset;
 491
 492       /* Only handle (PLUS (SYM, OFFSET)) form.  */
 493       addr = XEXP (addr, 0);
 494       if (GET_CODE (addr) != PLUS)
 495         return FALSE;
 496
 497       /* Make sure the address is word aligned.  */
 498       offset = XEXP (addr, 1);
 499       if ((GET_CODE (offset) != CONST_INT)
 500           || ((INTVAL (offset) & 3) != 0))
 501         return FALSE;
 502
 503       sym = XEXP (addr, 0);
 504     }
 505
 506   if ((GET_CODE (sym) == SYMBOL_REF)
 507       && CONSTANT_POOL_ADDRESS_P (sym))
 508     return TRUE;
 509   return FALSE;
 510 }
 511
 512
 513 int
 514 constantpool_mem_p (rtx op)
 515 {
 516   if (GET_CODE (op) == SUBREG)
 517     op = SUBREG_REG (op);
 518   if (GET_CODE (op) == MEM)
 519     return constantpool_address_p (XEXP (op, 0));
 520   return FALSE;
 521 }
 522
 523
 524 /* Return TRUE if X is a thread-local symbol.  */
 525
 526 static bool
 527 xtensa_tls_symbol_p (rtx x)
 528 {
 529   if (! TARGET_HAVE_TLS)
 530     return false;
 531
 532   return GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (x) != 0;
 533 }
 534
 535
 536 void
 537 xtensa_extend_reg (rtx dst, rtx src)
 538 {
 539   rtx temp = gen_reg_rtx (SImode);
 540   rtx shift = GEN_INT (BITS_PER_WORD - GET_MODE_BITSIZE (GET_MODE (src)));
 541
 542   /* Generate paradoxical subregs as needed so that the modes match.  */
 543   src = simplify_gen_subreg (SImode, src, GET_MODE (src), 0);
 544   dst = simplify_gen_subreg (SImode, dst, GET_MODE (dst), 0);
 545
 546   emit_insn (gen_ashlsi3 (temp, src, shift));
 547   emit_insn (gen_ashrsi3 (dst, temp, shift));
 548 }
 549
 550
 551 bool
 552 xtensa_mem_offset (unsigned v, enum machine_mode mode)
 553 {
 554   switch (mode)
 555     {
 556     case BLKmode:
 557       /* Handle the worst case for block moves.  See xtensa_expand_block_move
 558          where we emit an optimized block move operation if the block can be
 559          moved in < "move_ratio" pieces.  The worst case is when the block is
 560          aligned but has a size of (3 mod 4) (does this happen?) so that the
 561          last piece requires a byte load/store.  */
 562       return (xtensa_uimm8 (v)
 563               && xtensa_uimm8 (v + MOVE_MAX * LARGEST_MOVE_RATIO));
 564
 565     case QImode:
 566       return xtensa_uimm8 (v);
 567
 568     case HImode:
 569       return xtensa_uimm8x2 (v);
 570
 571     case DFmode:
 572       return (xtensa_uimm8x4 (v) && xtensa_uimm8x4 (v + 4));
 573
 574     default:
 575       break;
 576     }
 577
 578   return xtensa_uimm8x4 (v);
 579 }
 580
 581
 582 /* Make normal rtx_code into something we can index from an array.  */
 583
 584 static enum internal_test
 585 map_test_to_internal_test (enum rtx_code test_code)
 586 {
 587   enum internal_test test = ITEST_MAX;
 588
 589   switch (test_code)
 590     {
 591     default:                    break;
 592     case EQ:  test = ITEST_EQ;  break;
 593     case NE:  test = ITEST_NE;  break;
 594     case GT:  test = ITEST_GT;  break;
 595     case GE:  test = ITEST_GE;  break;
 596     case LT:  test = ITEST_LT;  break;
 597     case LE:  test = ITEST_LE;  break;
 598     case GTU: test = ITEST_GTU; break;
 599     case GEU: test = ITEST_GEU; break;
 600     case LTU: test = ITEST_LTU; break;
 601     case LEU: test = ITEST_LEU; break;
 602     }
 603
 604   return test;
 605 }
 606
 607
 608 /* Generate the code to compare two integer values.  The return value is
 609    the comparison expression.  */
 610
 611 static rtx
 612 gen_int_relational (enum rtx_code test_code, /* relational test (EQ, etc) */
 613                     rtx cmp0, /* first operand to compare */
 614                     rtx cmp1, /* second operand to compare */
 615                     int *p_invert /* whether branch needs to reverse test */)
 616 {
 617   struct cmp_info
 618   {
 619     enum rtx_code test_code;    /* test code to use in insn */
 620     bool (*const_range_p) (HOST_WIDE_INT); /* range check function */
 621     int const_add;              /* constant to add (convert LE -> LT) */
 622     int reverse_regs;           /* reverse registers in test */
 623     int invert_const;           /* != 0 if invert value if cmp1 is constant */
 624     int invert_reg;             /* != 0 if invert value if cmp1 is register */
 625     int unsignedp;              /* != 0 for unsigned comparisons.  */
 626   };
 627
 628   static struct cmp_info info[ (int)ITEST_MAX ] = {
 629
 630     { EQ,       xtensa_b4const_or_zero, 0, 0, 0, 0, 0 },        /* EQ  */
 631     { NE,       xtensa_b4const_or_zero, 0, 0, 0, 0, 0 },        /* NE  */
 632
 633     { LT,       xtensa_b4const_or_zero, 1, 1, 1, 0, 0 },        /* GT  */
 634     { GE,       xtensa_b4const_or_zero, 0, 0, 0, 0, 0 },        /* GE  */
 635     { LT,       xtensa_b4const_or_zero, 0, 0, 0, 0, 0 },        /* LT  */
 636     { GE,       xtensa_b4const_or_zero, 1, 1, 1, 0, 0 },        /* LE  */
 637
 638     { LTU,      xtensa_b4constu,        1, 1, 1, 0, 1 },        /* GTU */
 639     { GEU,      xtensa_b4constu,        0, 0, 0, 0, 1 },        /* GEU */
 640     { LTU,      xtensa_b4constu,        0, 0, 0, 0, 1 },        /* LTU */
 641     { GEU,      xtensa_b4constu,        1, 1, 1, 0, 1 },        /* LEU */
 642   };
 643
 644   enum internal_test test;
 645   enum machine_mode mode;
 646   struct cmp_info *p_info;
 647
 648   test = map_test_to_internal_test (test_code);
 649   gcc_assert (test != ITEST_MAX);
 650
 651   p_info = &info[ (int)test ];
 652
 653   mode = GET_MODE (cmp0);
 654   if (mode == VOIDmode)
 655     mode = GET_MODE (cmp1);
 656
 657   /* Make sure we can handle any constants given to us.  */
 658   if (GET_CODE (cmp1) == CONST_INT)
 659     {
 660       HOST_WIDE_INT value = INTVAL (cmp1);
 661       unsigned HOST_WIDE_INT uvalue = (unsigned HOST_WIDE_INT)value;
 662
 663       /* if the immediate overflows or does not fit in the immediate field,
 664          spill it to a register */
 665
 666       if ((p_info->unsignedp ?
 667            (uvalue + p_info->const_add > uvalue) :
 668            (value + p_info->const_add > value)) != (p_info->const_add > 0))
 669         {
 670           cmp1 = force_reg (mode, cmp1);
 671         }
 672       else if (!(p_info->const_range_p) (value + p_info->const_add))
 673         {
 674           cmp1 = force_reg (mode, cmp1);
 675         }
 676     }
 677   else if ((GET_CODE (cmp1) != REG) && (GET_CODE (cmp1) != SUBREG))
 678     {
 679       cmp1 = force_reg (mode, cmp1);
 680     }
 681
 682   /* See if we need to invert the result.  */
 683   *p_invert = ((GET_CODE (cmp1) == CONST_INT)
 684                ? p_info->invert_const
 685                : p_info->invert_reg);
 686
 687   /* Comparison to constants, may involve adding 1 to change a LT into LE.
 688      Comparison between two registers, may involve switching operands.  */
 689   if (GET_CODE (cmp1) == CONST_INT)
 690     {
 691       if (p_info->const_add != 0)
 692         cmp1 = GEN_INT (INTVAL (cmp1) + p_info->const_add);
 693
 694     }
 695   else if (p_info->reverse_regs)
 696     {
 697       rtx temp = cmp0;
 698       cmp0 = cmp1;
 699       cmp1 = temp;
 700     }
 701
 702   return gen_rtx_fmt_ee (p_info->test_code, VOIDmode, cmp0, cmp1);
 703 }
 704
 705
 706 /* Generate the code to compare two float values.  The return value is
 707    the comparison expression.  */
 708
 709 static rtx
 710 gen_float_relational (enum rtx_code test_code, /* relational test (EQ, etc) */
 711                       rtx cmp0, /* first operand to compare */
 712                       rtx cmp1 /* second operand to compare */)
 713 {
 714   rtx (*gen_fn) (rtx, rtx, rtx);
 715   rtx brtmp;
 716   int reverse_regs, invert;
 717
 718   switch (test_code)
 719     {
 720     case EQ: reverse_regs = 0; invert = 0; gen_fn = gen_seq_sf; break;
 721     case NE: reverse_regs = 0; invert = 1; gen_fn = gen_seq_sf; break;
 722     case LE: reverse_regs = 0; invert = 0; gen_fn = gen_sle_sf; break;
 723     case GT: reverse_regs = 1; invert = 0; gen_fn = gen_slt_sf; break;
 724     case LT: reverse_regs = 0; invert = 0; gen_fn = gen_slt_sf; break;
 725     case GE: reverse_regs = 1; invert = 0; gen_fn = gen_sle_sf; break;
 726     case UNEQ: reverse_regs = 0; invert = 0; gen_fn = gen_suneq_sf; break;
 727     case LTGT: reverse_regs = 0; invert = 1; gen_fn = gen_suneq_sf; break;
 728     case UNLE: reverse_regs = 0; invert = 0; gen_fn = gen_sunle_sf; break;
 729     case UNGT: reverse_regs = 1; invert = 0; gen_fn = gen_sunlt_sf; break;
 730     case UNLT: reverse_regs = 0; invert = 0; gen_fn = gen_sunlt_sf; break;
 731     case UNGE: reverse_regs = 1; invert = 0; gen_fn = gen_sunle_sf; break;
 732     case UNORDERED:
 733       reverse_regs = 0; invert = 0; gen_fn = gen_sunordered_sf; break;
 734     case ORDERED:
 735       reverse_regs = 0; invert = 1; gen_fn = gen_sunordered_sf; break;
 736     default:
 737       fatal_insn ("bad test", gen_rtx_fmt_ee (test_code, VOIDmode, cmp0, cmp1));
 738       reverse_regs = 0; invert = 0; gen_fn = 0; /* avoid compiler warnings */
 739     }
 740
 741   if (reverse_regs)
 742     {
 743       rtx temp = cmp0;
 744       cmp0 = cmp1;
 745       cmp1 = temp;
 746     }
 747
 748   brtmp = gen_rtx_REG (CCmode, FPCC_REGNUM);
 749   emit_insn (gen_fn (brtmp, cmp0, cmp1));
 750
 751   return gen_rtx_fmt_ee (invert ? EQ : NE, VOIDmode, brtmp, const0_rtx);
 752 }
 753
 754
 755 void
 756 xtensa_expand_conditional_branch (rtx *operands, enum machine_mode mode)
 757 {
 758   enum rtx_code test_code = GET_CODE (operands[0]);
 759   rtx cmp0 = operands[1];
 760   rtx cmp1 = operands[2];
 761   rtx cmp;
 762   int invert;
 763   rtx label1, label2;
 764
 765   switch (mode)
 766     {
 767     case DFmode:
 768     default:
 769       fatal_insn ("bad test", gen_rtx_fmt_ee (test_code, VOIDmode, cmp0, cmp1));
 770
 771     case SImode:
 772       invert = FALSE;
 773       cmp = gen_int_relational (test_code, cmp0, cmp1, &invert);
 774       break;
 775
 776     case SFmode:
 777       if (!TARGET_HARD_FLOAT)
 778         fatal_insn ("bad test", gen_rtx_fmt_ee (test_code, VOIDmode,
 779                                                 cmp0, cmp1));
 780       invert = FALSE;
 781       cmp = gen_float_relational (test_code, cmp0, cmp1);
 782       break;
 783     }
 784
 785   /* Generate the branch.  */
 786
 787   label1 = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
 788   label2 = pc_rtx;
 789
 790   if (invert)
 791     {
 792       label2 = label1;
 793       label1 = pc_rtx;
 794     }
 795
 796   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
 797                                gen_rtx_IF_THEN_ELSE (VOIDmode, cmp,
 798                                                      label1,
 799                                                      label2)));
 800 }
 801
 802
 803 static rtx
 804 gen_conditional_move (enum rtx_code code, enum machine_mode mode,
 805                       rtx op0, rtx op1)
 806 {
 807   if (mode == SImode)
 808     {
 809       rtx cmp;
 810
 811       /* Jump optimization calls get_condition() which canonicalizes
 812          comparisons like (GE x <const>) to (GT x <const-1>).
 813          Transform those comparisons back to GE, since that is the
 814          comparison supported in Xtensa.  We shouldn't have to
 815          transform <LE x const> comparisons, because neither
 816          xtensa_expand_conditional_branch() nor get_condition() will
 817          produce them.  */
 818
 819       if ((code == GT) && (op1 == constm1_rtx))
 820         {
 821           code = GE;
 822           op1 = const0_rtx;
 823         }
 824       cmp = gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
 825
 826       if (boolean_operator (cmp, VOIDmode))
 827         {
 828           /* Swap the operands to make const0 second.  */
 829           if (op0 == const0_rtx)
 830             {
 831               op0 = op1;
 832               op1 = const0_rtx;
 833             }
 834
 835           /* If not comparing against zero, emit a comparison (subtract).  */
 836           if (op1 != const0_rtx)
 837             {
 838               op0 = expand_binop (SImode, sub_optab, op0, op1,
 839                                   0, 0, OPTAB_LIB_WIDEN);
 840               op1 = const0_rtx;
 841             }
 842         }
 843       else if (branch_operator (cmp, VOIDmode))
 844         {
 845           /* Swap the operands to make const0 second.  */
 846           if (op0 == const0_rtx)
 847             {
 848               op0 = op1;
 849               op1 = const0_rtx;
 850
 851               switch (code)
 852                 {
 853                 case LT: code = GE; break;
 854                 case GE: code = LT; break;
 855                 default: gcc_unreachable ();
 856                 }
 857             }
 858
 859           if (op1 != const0_rtx)
 860             return 0;
 861         }
 862       else
 863         return 0;
 864
 865       return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
 866     }
 867
 868   if (TARGET_HARD_FLOAT && mode == SFmode)
 869     return gen_float_relational (code, op0, op1);
 870
 871   return 0;
 872 }
 873
 874
 875 int
 876 xtensa_expand_conditional_move (rtx *operands, int isflt)
 877 {
 878   rtx dest = operands[0];
 879   rtx cmp = operands[1];
 880   enum machine_mode cmp_mode = GET_MODE (XEXP (cmp, 0));
 881   rtx (*gen_fn) (rtx, rtx, rtx, rtx, rtx);
 882
 883   if (!(cmp = gen_conditional_move (GET_CODE (cmp), cmp_mode,
 884                                     XEXP (cmp, 0), XEXP (cmp, 1))))
 885     return 0;
 886
 887   if (isflt)
 888     gen_fn = (cmp_mode == SImode
 889               ? gen_movsfcc_internal0
 890               : gen_movsfcc_internal1);
 891   else
 892     gen_fn = (cmp_mode == SImode
 893               ? gen_movsicc_internal0
 894               : gen_movsicc_internal1);
 895
 896   emit_insn (gen_fn (dest, XEXP (cmp, 0), operands[2], operands[3], cmp));
 897   return 1;
 898 }
 899
 900
 901 int
 902 xtensa_expand_scc (rtx operands[4], enum machine_mode cmp_mode)
 903 {
 904   rtx dest = operands[0];
 905   rtx cmp;
 906   rtx one_tmp, zero_tmp;
 907   rtx (*gen_fn) (rtx, rtx, rtx, rtx, rtx);
 908
 909   if (!(cmp = gen_conditional_move (GET_CODE (operands[1]), cmp_mode,
 910                                     operands[2], operands[3])))
 911     return 0;
 912
 913   one_tmp = gen_reg_rtx (SImode);
 914   zero_tmp = gen_reg_rtx (SImode);
 915   emit_insn (gen_movsi (one_tmp, const_true_rtx));
 916   emit_insn (gen_movsi (zero_tmp, const0_rtx));
 917
 918   gen_fn = (cmp_mode == SImode
 919             ? gen_movsicc_internal0
 920             : gen_movsicc_internal1);
 921   emit_insn (gen_fn (dest, XEXP (cmp, 0), one_tmp, zero_tmp, cmp));
 922   return 1;
 923 }
 924
 925
 926 /* Split OP[1] into OP[2,3] and likewise for OP[0] into OP[0,1].  MODE is
 927    for the output, i.e., the input operands are twice as big as MODE.  */
 928
 929 void
 930 xtensa_split_operand_pair (rtx operands[4], enum machine_mode mode)
 931 {
 932   switch (GET_CODE (operands[1]))
 933     {
 934     case REG:
 935       operands[3] = gen_rtx_REG (mode, REGNO (operands[1]) + 1);
 936       operands[2] = gen_rtx_REG (mode, REGNO (operands[1]));
 937       break;
 938
 939     case MEM:
 940       operands[3] = adjust_address (operands[1], mode, GET_MODE_SIZE (mode));
 941       operands[2] = adjust_address (operands[1], mode, 0);
 942       break;
 943
 944     case CONST_INT:
 945     case CONST_DOUBLE:
 946       split_double (operands[1], &operands[2], &operands[3]);
 947       break;
 948
 949     default:
 950       gcc_unreachable ();
 951     }
 952
 953   switch (GET_CODE (operands[0]))
 954     {
 955     case REG:
 956       operands[1] = gen_rtx_REG (mode, REGNO (operands[0]) + 1);
 957       operands[0] = gen_rtx_REG (mode, REGNO (operands[0]));
 958       break;
 959
 960     case MEM:
 961       operands[1] = adjust_address (operands[0], mode, GET_MODE_SIZE (mode));
 962       operands[0] = adjust_address (operands[0], mode, 0);
 963       break;
 964
 965     default:
 966       gcc_unreachable ();
 967     }
 968 }
 969
 970
 971 /* Emit insns to move operands[1] into operands[0].
 972    Return 1 if we have written out everything that needs to be done to
 973    do the move.  Otherwise, return 0 and the caller will emit the move
 974    normally.  */
 975
 976 int
 977 xtensa_emit_move_sequence (rtx *operands, enum machine_mode mode)
 978 {
 979   rtx src = operands[1];
 980
 981   if (CONSTANT_P (src)
 982       && (GET_CODE (src) != CONST_INT || ! xtensa_simm12b (INTVAL (src))))
 983     {
 984       rtx dst = operands[0];
 985
 986       if (xtensa_tls_referenced_p (src))
 987         {
 988           rtx addend = NULL;
 989
 990           if (GET_CODE (src) == CONST && GET_CODE (XEXP (src, 0)) == PLUS)
 991             {
 992               addend = XEXP (XEXP (src, 0), 1);
 993               src = XEXP (XEXP (src, 0), 0);
 994             }
 995
 996           src = xtensa_legitimize_tls_address (src);
 997           if (addend)
 998             {
 999               src = gen_rtx_PLUS (mode, src, addend);
1000               src = force_operand (src, dst);
1001             }
1002           emit_move_insn (dst, src);
1003           return 1;
1004         }
1005
1006       if (! TARGET_CONST16)
1007         {
1008           src = force_const_mem (SImode, src);
1009           operands[1] = src;
1010         }
1011
1012       /* PC-relative loads are always SImode, and CONST16 is only
1013          supported in the movsi pattern, so add a SUBREG for any other
1014          (smaller) mode.  */
1015
1016       if (mode != SImode)
1017         {
1018           if (register_operand (dst, mode))
1019             {
1020               emit_move_insn (simplify_gen_subreg (SImode, dst, mode, 0), src);
1021               return 1;
1022             }
1023           else
1024             {
1025               src = force_reg (SImode, src);
1026               src = gen_lowpart_SUBREG (mode, src);
1027               operands[1] = src;
1028             }
1029         }
1030     }
1031
1032   if (!(reload_in_progress | reload_completed)
1033       && !xtensa_valid_move (mode, operands))
1034     operands[1] = force_reg (mode, operands[1]);
1035
1036   operands[1] = xtensa_copy_incoming_a7 (operands[1]);
1037
1038   /* During reload we don't want to emit (subreg:X (mem:Y)) since that
1039      instruction won't be recognized after reload, so we remove the
1040      subreg and adjust mem accordingly.  */
1041   if (reload_in_progress)
1042     {
1043       operands[0] = fixup_subreg_mem (operands[0]);
1044       operands[1] = fixup_subreg_mem (operands[1]);
1045     }
1046   return 0;
1047 }
1048
1049
1050 static rtx
1051 fixup_subreg_mem (rtx x)
1052 {
1053   if (GET_CODE (x) == SUBREG
1054       && GET_CODE (SUBREG_REG (x)) == REG
1055       && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER)
1056     {
1057       rtx temp =
1058         gen_rtx_SUBREG (GET_MODE (x),
1059                         reg_equiv_mem [REGNO (SUBREG_REG (x))],
1060                         SUBREG_BYTE (x));
1061       x = alter_subreg (&temp);
1062     }
1063   return x;
1064 }
1065
1066
1067 /* Check if an incoming argument in a7 is expected to be used soon and
1068    if OPND is a register or register pair that includes a7.  If so,
1069    create a new pseudo and copy a7 into that pseudo at the very
1070    beginning of the function, followed by the special "set_frame_ptr"
1071    unspec_volatile insn.  The return value is either the original
1072    operand, if it is not a7, or the new pseudo containing a copy of
1073    the incoming argument.  This is necessary because the register
1074    allocator will ignore conflicts with a7 and may either assign some
1075    other pseudo to a7 or use a7 as the hard_frame_pointer, clobbering
1076    the incoming argument in a7.  By copying the argument out of a7 as
1077    the very first thing, and then immediately following that with an
1078    unspec_volatile to keep the scheduler away, we should avoid any
1079    problems.  Putting the set_frame_ptr insn at the beginning, with
1080    only the a7 copy before it, also makes it easier for the prologue
1081    expander to initialize the frame pointer after the a7 copy and to
1082    fix up the a7 copy to use the stack pointer instead of the frame
1083    pointer.  */
1084
1085 rtx
1086 xtensa_copy_incoming_a7 (rtx opnd)
1087 {
1088   rtx entry_insns = 0;
1089   rtx reg, tmp;
1090   enum machine_mode mode;
1091
1092   if (!cfun->machine->need_a7_copy)
1093     return opnd;
1094
1095   /* This function should never be called again once a7 has been copied.  */
1096   gcc_assert (!cfun->machine->set_frame_ptr_insn);
1097
1098   mode = GET_MODE (opnd);
1099
1100   /* The operand using a7 may come in a later instruction, so just return
1101      the original operand if it doesn't use a7.  */
1102   reg = opnd;
1103   if (GET_CODE (reg) == SUBREG)
1104     {
1105       gcc_assert (SUBREG_BYTE (reg) == 0);
1106       reg = SUBREG_REG (reg);
1107     }
1108   if (GET_CODE (reg) != REG
1109       || REGNO (reg) > A7_REG
1110       || REGNO (reg) + HARD_REGNO_NREGS (A7_REG, mode) <= A7_REG)
1111     return opnd;
1112
1113   /* 1-word args will always be in a7; 2-word args in a6/a7.  */
1114   gcc_assert (REGNO (reg) + HARD_REGNO_NREGS (A7_REG, mode) - 1 == A7_REG);
1115
1116   cfun->machine->need_a7_copy = false;
1117
1118   /* Copy a7 to a new pseudo at the function entry.  Use gen_raw_REG to
1119      create the REG for a7 so that hard_frame_pointer_rtx is not used.  */
1120
1121   start_sequence ();
1122   tmp = gen_reg_rtx (mode);
1123
1124   switch (mode)
1125     {
1126     case DFmode:
1127     case DImode:
1128       /* Copy the value out of A7 here but keep the first word in A6 until
1129          after the set_frame_ptr insn.  Otherwise, the register allocator
1130          may decide to put "subreg (tmp, 0)" in A7 and clobber the incoming
1131          value.  */
1132       emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 4),
1133                                      gen_raw_REG (SImode, A7_REG)));
1134       break;
1135     case SFmode:
1136       emit_insn (gen_movsf_internal (tmp, gen_raw_REG (mode, A7_REG)));
1137       break;
1138     case SImode:
1139       emit_insn (gen_movsi_internal (tmp, gen_raw_REG (mode, A7_REG)));
1140       break;
1141     case HImode:
1142       emit_insn (gen_movhi_internal (tmp, gen_raw_REG (mode, A7_REG)));
1143       break;
1144     case QImode:
1145       emit_insn (gen_movqi_internal (tmp, gen_raw_REG (mode, A7_REG)));
1146       break;
1147     default:
1148       gcc_unreachable ();
1149     }
1150
1151   cfun->machine->set_frame_ptr_insn = emit_insn (gen_set_frame_ptr ());
1152
1153   /* For DF and DI mode arguments, copy the incoming value in A6 now.  */
1154   if (mode == DFmode || mode == DImode)
1155     emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 0),
1156                                    gen_rtx_REG (SImode, A7_REG - 1)));
1157   entry_insns = get_insns ();
1158   end_sequence ();
1159
1160   if (cfun->machine->vararg_a7)
1161     {
1162       /* This is called from within builtin_saveregs, which will insert the
1163          saveregs code at the function entry, ahead of anything placed at
1164          the function entry now.  Instead, save the sequence to be inserted
1165          at the beginning of the saveregs code.  */
1166       cfun->machine->vararg_a7_copy = entry_insns;
1167     }
1168   else
1169     {
1170       /* Put entry_insns after the NOTE that starts the function.  If
1171          this is inside a start_sequence, make the outer-level insn
1172          chain current, so the code is placed at the start of the
1173          function.  */
1174       push_topmost_sequence ();
1175       /* Do not use entry_of_function() here.  This is called from within
1176          expand_function_start, when the CFG still holds GIMPLE.  */
1177       emit_insn_after (entry_insns, get_insns ());
1178       pop_topmost_sequence ();
1179     }
1180
1181   return tmp;
1182 }
1183
1184
1185 /* Try to expand a block move operation to a sequence of RTL move
1186    instructions.  If not optimizing, or if the block size is not a
1187    constant, or if the block is too large, the expansion fails and GCC
1188    falls back to calling memcpy().
1189
1190    operands[0] is the destination
1191    operands[1] is the source
1192    operands[2] is the length
1193    operands[3] is the alignment */
1194
1195 int
1196 xtensa_expand_block_move (rtx *operands)
1197 {
1198   static const enum machine_mode mode_from_align[] =
1199   {
1200     VOIDmode, QImode, HImode, VOIDmode, SImode,
1201   };
1202
1203   rtx dst_mem = operands[0];
1204   rtx src_mem = operands[1];
1205   HOST_WIDE_INT bytes, align;
1206   int num_pieces, move_ratio;
1207   rtx temp[2];
1208   enum machine_mode mode[2];
1209   int amount[2];
1210   bool active[2];
1211   int phase = 0;
1212   int next;
1213   int offset_ld = 0;
1214   int offset_st = 0;
1215   rtx x;
1216
1217   /* If this is not a fixed size move, just call memcpy.  */
1218   if (!optimize || (GET_CODE (operands[2]) != CONST_INT))
1219     return 0;
1220
1221   bytes = INTVAL (operands[2]);
1222   align = INTVAL (operands[3]);
1223
1224   /* Anything to move?  */
1225   if (bytes <= 0)
1226     return 0;
1227
1228   if (align > MOVE_MAX)
1229     align = MOVE_MAX;
1230
1231   /* Decide whether to expand inline based on the optimization level.  */
1232   move_ratio = 4;
1233   if (optimize > 2)
1234     move_ratio = LARGEST_MOVE_RATIO;
1235   num_pieces = (bytes / align) + (bytes % align); /* Close enough anyway.  */
1236   if (num_pieces > move_ratio)
1237     return 0;
1238
1239   x = XEXP (dst_mem, 0);
1240   if (!REG_P (x))
1241     {
1242       x = force_reg (Pmode, x);
1243       dst_mem = replace_equiv_address (dst_mem, x);
1244     }
1245
1246   x = XEXP (src_mem, 0);
1247   if (!REG_P (x))
1248     {
1249       x = force_reg (Pmode, x);
1250       src_mem = replace_equiv_address (src_mem, x);
1251     }
1252
1253   active[0] = active[1] = false;
1254
1255   do
1256     {
1257       next = phase;
1258       phase ^= 1;
1259
1260       if (bytes > 0)
1261         {
1262           int next_amount;
1263
1264           next_amount = (bytes >= 4 ? 4 : (bytes >= 2 ? 2 : 1));
1265           next_amount = MIN (next_amount, align);
1266
1267           amount[next] = next_amount;
1268           mode[next] = mode_from_align[next_amount];
1269           temp[next] = gen_reg_rtx (mode[next]);
1270
1271           x = adjust_address (src_mem, mode[next], offset_ld);
1272           emit_insn (gen_rtx_SET (VOIDmode, temp[next], x));
1273
1274           offset_ld += next_amount;
1275           bytes -= next_amount;
1276           active[next] = true;
1277         }
1278
1279       if (active[phase])
1280         {
1281           active[phase] = false;
1282
1283           x = adjust_address (dst_mem, mode[phase], offset_st);
1284           emit_insn (gen_rtx_SET (VOIDmode, x, temp[phase]));
1285
1286           offset_st += amount[phase];
1287         }
1288     }
1289   while (active[next]);
1290
1291   return 1;
1292 }
1293
1294
1295 void
1296 xtensa_expand_nonlocal_goto (rtx *operands)
1297 {
1298   rtx goto_handler = operands[1];
1299   rtx containing_fp = operands[3];
1300
1301   /* Generate a call to "__xtensa_nonlocal_goto" (in libgcc); the code
1302      is too big to generate in-line.  */
1303
1304   if (GET_CODE (containing_fp) != REG)
1305     containing_fp = force_reg (Pmode, containing_fp);
1306
1307   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__xtensa_nonlocal_goto"),
1308                      0, VOIDmode, 2,
1309                      containing_fp, Pmode,
1310                      goto_handler, Pmode);
1311 }
1312
1313
1314 static struct machine_function *
1315 xtensa_init_machine_status (void)
1316 {
1317   return ggc_alloc_cleared_machine_function ();
1318 }
1319
1320
1321 /* Shift VAL of mode MODE left by COUNT bits.  */
1322
1323 static inline rtx
1324 xtensa_expand_mask_and_shift (rtx val, enum machine_mode mode, rtx count)
1325 {
1326   val = expand_simple_binop (SImode, AND, val, GEN_INT (GET_MODE_MASK (mode)),
1327                              NULL_RTX, 1, OPTAB_DIRECT);
1328   return expand_simple_binop (SImode, ASHIFT, val, count,
1329                               NULL_RTX, 1, OPTAB_DIRECT);
1330 }
1331
1332
1333 /* Structure to hold the initial parameters for a compare_and_swap operation
1334    in HImode and QImode.  */
1335
1336 struct alignment_context
1337 {
1338   rtx memsi;      /* SI aligned memory location.  */
1339   rtx shift;      /* Bit offset with regard to lsb.  */
1340   rtx modemask;   /* Mask of the HQImode shifted by SHIFT bits.  */
1341   rtx modemaski;  /* ~modemask */
1342 };
1343
1344
1345 /* Initialize structure AC for word access to HI and QI mode memory.  */
1346
1347 static void
1348 init_alignment_context (struct alignment_context *ac, rtx mem)
1349 {
1350   enum machine_mode mode = GET_MODE (mem);
1351   rtx byteoffset = NULL_RTX;
1352   bool aligned = (MEM_ALIGN (mem) >= GET_MODE_BITSIZE (SImode));
1353
1354   if (aligned)
1355     ac->memsi = adjust_address (mem, SImode, 0); /* Memory is aligned.  */
1356   else
1357     {
1358       /* Alignment is unknown.  */
1359       rtx addr, align;
1360
1361       /* Force the address into a register.  */
1362       addr = force_reg (Pmode, XEXP (mem, 0));
1363
1364       /* Align it to SImode.  */
1365       align = expand_simple_binop (Pmode, AND, addr,
1366                                    GEN_INT (-GET_MODE_SIZE (SImode)),
1367                                    NULL_RTX, 1, OPTAB_DIRECT);
1368       /* Generate MEM.  */
1369       ac->memsi = gen_rtx_MEM (SImode, align);
1370       MEM_VOLATILE_P (ac->memsi) = MEM_VOLATILE_P (mem);
1371       set_mem_alias_set (ac->memsi, ALIAS_SET_MEMORY_BARRIER);
1372       set_mem_align (ac->memsi, GET_MODE_BITSIZE (SImode));
1373
1374       byteoffset = expand_simple_binop (Pmode, AND, addr,
1375                                         GEN_INT (GET_MODE_SIZE (SImode) - 1),
1376                                         NULL_RTX, 1, OPTAB_DIRECT);
1377     }
1378
1379   /* Calculate shiftcount.  */
1380   if (TARGET_BIG_ENDIAN)
1381     {
1382       ac->shift = GEN_INT (GET_MODE_SIZE (SImode) - GET_MODE_SIZE (mode));
1383       if (!aligned)
1384         ac->shift = expand_simple_binop (SImode, MINUS, ac->shift, byteoffset,
1385                                          NULL_RTX, 1, OPTAB_DIRECT);
1386     }
1387   else
1388     {
1389       if (aligned)
1390         ac->shift = NULL_RTX;
1391       else
1392         ac->shift = byteoffset;
1393     }
1394
1395   if (ac->shift != NULL_RTX)
1396     {
1397       /* Shift is the byte count, but we need the bitcount.  */
1398       ac->shift = expand_simple_binop (SImode, MULT, ac->shift,
1399                                        GEN_INT (BITS_PER_UNIT),
1400                                        NULL_RTX, 1, OPTAB_DIRECT);
1401       ac->modemask = expand_simple_binop (SImode, ASHIFT,
1402                                           GEN_INT (GET_MODE_MASK (mode)),
1403                                           ac->shift,
1404                                           NULL_RTX, 1, OPTAB_DIRECT);
1405     }
1406   else
1407     ac->modemask = GEN_INT (GET_MODE_MASK (mode));
1408
1409   ac->modemaski = expand_simple_unop (SImode, NOT, ac->modemask, NULL_RTX, 1);
1410 }
1411
1412
1413 /* Expand an atomic compare and swap operation for HImode and QImode.
1414    MEM is the memory location, CMP the old value to compare MEM with
1415    and NEW_RTX the value to set if CMP == MEM.  */
1416
1417 void
1418 xtensa_expand_compare_and_swap (rtx target, rtx mem, rtx cmp, rtx new_rtx)
1419 {
1420   enum machine_mode mode = GET_MODE (mem);
1421   struct alignment_context ac;
1422   rtx tmp, cmpv, newv, val;
1423   rtx oldval = gen_reg_rtx (SImode);
1424   rtx res = gen_reg_rtx (SImode);
1425   rtx csloop = gen_label_rtx ();
1426   rtx csend = gen_label_rtx ();
1427
1428   init_alignment_context (&ac, mem);
1429
1430   if (ac.shift != NULL_RTX)
1431     {
1432       cmp = xtensa_expand_mask_and_shift (cmp, mode, ac.shift);
1433       new_rtx = xtensa_expand_mask_and_shift (new_rtx, mode, ac.shift);
1434     }
1435
1436   /* Load the surrounding word into VAL with the MEM value masked out.  */
1437   val = force_reg (SImode, expand_simple_binop (SImode, AND, ac.memsi,
1438                                                 ac.modemaski, NULL_RTX, 1,
1439                                                 OPTAB_DIRECT));
1440   emit_label (csloop);
1441
1442   /* Patch CMP and NEW_RTX into VAL at correct position.  */
1443   cmpv = force_reg (SImode, expand_simple_binop (SImode, IOR, cmp, val,
1444                                                  NULL_RTX, 1, OPTAB_DIRECT));
1445   newv = force_reg (SImode, expand_simple_binop (SImode, IOR, new_rtx, val,
1446                                                  NULL_RTX, 1, OPTAB_DIRECT));
1447
1448   /* Jump to end if we're done.  */
1449   emit_insn (gen_sync_compare_and_swapsi (res, ac.memsi, cmpv, newv));
1450   emit_cmp_and_jump_insns (res, cmpv, EQ, const0_rtx, SImode, true, csend);
1451
1452   /* Check for changes outside mode.  */
1453   emit_move_insn (oldval, val);
1454   tmp = expand_simple_binop (SImode, AND, res, ac.modemaski,
1455                              val, 1, OPTAB_DIRECT);
1456   if (tmp != val)
1457     emit_move_insn (val, tmp);
1458
1459   /* Loop internal if so.  */
1460   emit_cmp_and_jump_insns (oldval, val, NE, const0_rtx, SImode, true, csloop);
1461
1462   emit_label (csend);
1463
1464   /* Return the correct part of the bitfield.  */
1465   convert_move (target,
1466                 (ac.shift == NULL_RTX ? res
1467                  : expand_simple_binop (SImode, LSHIFTRT, res, ac.shift,
1468                                         NULL_RTX, 1, OPTAB_DIRECT)),
1469                 1);
1470 }
1471
1472
1473 /* Expand an atomic operation CODE of mode MODE (either HImode or QImode --
1474    the default expansion works fine for SImode).  MEM is the memory location
1475    and VAL the value to play with.  If AFTER is true then store the value
1476    MEM holds after the operation, if AFTER is false then store the value MEM
1477    holds before the operation.  If TARGET is zero then discard that value, else
1478    store it to TARGET.  */
1479
1480 void
1481 xtensa_expand_atomic (enum rtx_code code, rtx target, rtx mem, rtx val,
1482                       bool after)
1483 {
1484   enum machine_mode mode = GET_MODE (mem);
1485   struct alignment_context ac;
1486   rtx csloop = gen_label_rtx ();
1487   rtx cmp, tmp;
1488   rtx old = gen_reg_rtx (SImode);
1489   rtx new_rtx = gen_reg_rtx (SImode);
1490   rtx orig = NULL_RTX;
1491
1492   init_alignment_context (&ac, mem);
1493
1494   /* Prepare values before the compare-and-swap loop.  */
1495   if (ac.shift != NULL_RTX)
1496     val = xtensa_expand_mask_and_shift (val, mode, ac.shift);
1497   switch (code)
1498     {
1499     case PLUS:
1500     case MINUS:
1501       orig = gen_reg_rtx (SImode);
1502       convert_move (orig, val, 1);
1503       break;
1504
1505     case SET:
1506     case IOR:
1507     case XOR:
1508       break;
1509
1510     case MULT: /* NAND */
1511     case AND:
1512       /* val = "11..1<val>11..1" */
1513       val = expand_simple_binop (SImode, XOR, val, ac.modemaski,
1514                                  NULL_RTX, 1, OPTAB_DIRECT);
1515       break;
1516
1517     default:
1518       gcc_unreachable ();
1519     }
1520
1521   /* Load full word.  Subsequent loads are performed by S32C1I.  */
1522   cmp = force_reg (SImode, ac.memsi);
1523
1524   emit_label (csloop);
1525   emit_move_insn (old, cmp);
1526
1527   switch (code)
1528     {
1529     case PLUS:
1530     case MINUS:
1531       val = expand_simple_binop (SImode, code, old, orig,
1532                                  NULL_RTX, 1, OPTAB_DIRECT);
1533       val = expand_simple_binop (SImode, AND, val, ac.modemask,
1534                                  NULL_RTX, 1, OPTAB_DIRECT);
1535       /* FALLTHRU */
1536     case SET:
1537       tmp = expand_simple_binop (SImode, AND, old, ac.modemaski,
1538                                  NULL_RTX, 1, OPTAB_DIRECT);
1539       tmp = expand_simple_binop (SImode, IOR, tmp, val,
1540                                  new_rtx, 1, OPTAB_DIRECT);
1541       break;
1542
1543     case AND:
1544     case IOR:
1545     case XOR:
1546       tmp = expand_simple_binop (SImode, code, old, val,
1547                                  new_rtx, 1, OPTAB_DIRECT);
1548       break;
1549
1550     case MULT: /* NAND */
1551       tmp = expand_simple_binop (SImode, XOR, old, ac.modemask,
1552                                  NULL_RTX, 1, OPTAB_DIRECT);
1553       tmp = expand_simple_binop (SImode, AND, tmp, val,
1554                                  new_rtx, 1, OPTAB_DIRECT);
1555       break;
1556
1557     default:
1558       gcc_unreachable ();
1559     }
1560
1561   if (tmp != new_rtx)
1562     emit_move_insn (new_rtx, tmp);
1563   emit_insn (gen_sync_compare_and_swapsi (cmp, ac.memsi, old, new_rtx));
1564   emit_cmp_and_jump_insns (cmp, old, NE, const0_rtx, SImode, true, csloop);
1565
1566   if (target)
1567     {
1568       tmp = (after ? new_rtx : cmp);
1569       convert_move (target,
1570                     (ac.shift == NULL_RTX ? tmp
1571                      : expand_simple_binop (SImode, LSHIFTRT, tmp, ac.shift,
1572                                             NULL_RTX, 1, OPTAB_DIRECT)),
1573                     1);
1574     }
1575 }
1576
1577
1578 void
1579 xtensa_setup_frame_addresses (void)
1580 {
1581   /* Set flag to cause TARGET_FRAME_POINTER_REQUIRED to return true.  */
1582   cfun->machine->accesses_prev_frame = 1;
1583
1584   emit_library_call
1585     (gen_rtx_SYMBOL_REF (Pmode, "__xtensa_libgcc_window_spill"),
1586      0, VOIDmode, 0);
1587 }
1588
1589
1590 /* Emit the assembly for the end of a zero-cost loop.  Normally we just emit
1591    a comment showing where the end of the loop is.  However, if there is a
1592    label or a branch at the end of the loop then we need to place a nop
1593    there.  If the loop ends with a label we need the nop so that branches
1594    targeting that label will target the nop (and thus remain in the loop),
1595    instead of targeting the instruction after the loop (and thus exiting
1596    the loop).  If the loop ends with a branch, we need the nop in case the
1597    branch is targeting a location inside the loop.  When the branch
1598    executes it will cause the loop count to be decremented even if it is
1599    taken (because it is the last instruction in the loop), so we need to
1600    nop after the branch to prevent the loop count from being decremented
1601    when the branch is taken.  */
1602
1603 void
1604 xtensa_emit_loop_end (rtx insn, rtx *operands)
1605 {
1606   char done = 0;
1607
1608   for (insn = PREV_INSN (insn); insn && !done; insn = PREV_INSN (insn))
1609     {
1610       switch (GET_CODE (insn))
1611         {
1612         case NOTE:
1613         case BARRIER:
1614           break;
1615
1616         case CODE_LABEL:
1617           output_asm_insn (TARGET_DENSITY ? "nop.n" : "nop", operands);
1618           done = 1;
1619           break;
1620
1621         default:
1622           {
1623             rtx body = PATTERN (insn);
1624
1625             if (GET_CODE (body) == JUMP_INSN)
1626               {
1627                 output_asm_insn (TARGET_DENSITY ? "nop.n" : "nop", operands);
1628                 done = 1;
1629               }
1630             else if ((GET_CODE (body) != USE)
1631                      && (GET_CODE (body) != CLOBBER))
1632               done = 1;
1633           }
1634           break;
1635         }
1636     }
1637
1638   output_asm_insn ("# loop end for %0", operands);
1639 }
1640
1641
1642 char *
1643 xtensa_emit_branch (bool inverted, bool immed, rtx *operands)
1644 {
1645   static char result[64];
1646   enum rtx_code code;
1647   const char *op;
1648
1649   code = GET_CODE (operands[3]);
1650   switch (code)
1651     {
1652     case EQ:    op = inverted ? "ne" : "eq"; break;
1653     case NE:    op = inverted ? "eq" : "ne"; break;
1654     case LT:    op = inverted ? "ge" : "lt"; break;
1655     case GE:    op = inverted ? "lt" : "ge"; break;
1656     case LTU:   op = inverted ? "geu" : "ltu"; break;
1657     case GEU:   op = inverted ? "ltu" : "geu"; break;
1658     default:    gcc_unreachable ();
1659     }
1660
1661   if (immed)
1662     {
1663       if (INTVAL (operands[1]) == 0)
1664         sprintf (result, "b%sz%s\t%%0, %%2", op,
1665                  (TARGET_DENSITY && (code == EQ || code == NE)) ? ".n" : "");
1666       else
1667         sprintf (result, "b%si\t%%0, %%d1, %%2", op);
1668     }
1669   else
1670     sprintf (result, "b%s\t%%0, %%1, %%2", op);
1671
1672   return result;
1673 }
1674
1675
1676 char *
1677 xtensa_emit_bit_branch (bool inverted, bool immed, rtx *operands)
1678 {
1679   static char result[64];
1680   const char *op;
1681
1682   switch (GET_CODE (operands[3]))
1683     {
1684     case EQ:    op = inverted ? "bs" : "bc"; break;
1685     case NE:    op = inverted ? "bc" : "bs"; break;
1686     default:    gcc_unreachable ();
1687     }
1688
1689   if (immed)
1690     {
1691       unsigned bitnum = INTVAL (operands[1]) & 0x1f;
1692       operands[1] = GEN_INT (bitnum);
1693       sprintf (result, "b%si\t%%0, %%d1, %%2", op);
1694     }
1695   else
1696     sprintf (result, "b%s\t%%0, %%1, %%2", op);
1697
1698   return result;
1699 }
1700
1701
1702 char *
1703 xtensa_emit_movcc (bool inverted, bool isfp, bool isbool, rtx *operands)
1704 {
1705   static char result[64];
1706   enum rtx_code code;
1707   const char *op;
1708
1709   code = GET_CODE (operands[4]);
1710   if (isbool)
1711     {
1712       switch (code)
1713         {
1714         case EQ:        op = inverted ? "t" : "f"; break;
1715         case NE:        op = inverted ? "f" : "t"; break;
1716         default:        gcc_unreachable ();
1717         }
1718     }
1719   else
1720     {
1721       switch (code)
1722         {
1723         case EQ:        op = inverted ? "nez" : "eqz"; break;
1724         case NE:        op = inverted ? "eqz" : "nez"; break;
1725         case LT:        op = inverted ? "gez" : "ltz"; break;
1726         case GE:        op = inverted ? "ltz" : "gez"; break;
1727         default:        gcc_unreachable ();
1728         }
1729     }
1730
1731   sprintf (result, "mov%s%s\t%%0, %%%d, %%1",
1732            op, isfp ? ".s" : "", inverted ? 3 : 2);
1733   return result;
1734 }
1735
1736
1737 char *
1738 xtensa_emit_call (int callop, rtx *operands)
1739 {
1740   static char result[64];
1741   rtx tgt = operands[callop];
1742
1743   if (GET_CODE (tgt) == CONST_INT)
1744     sprintf (result, "call8\t0x%lx", INTVAL (tgt));
1745   else if (register_operand (tgt, VOIDmode))
1746     sprintf (result, "callx8\t%%%d", callop);
1747   else
1748     sprintf (result, "call8\t%%%d", callop);
1749
1750   return result;
1751 }
1752
1753
1754 bool
1755 xtensa_legitimate_address_p (enum machine_mode mode, rtx addr, bool strict)
1756 {
1757   /* Allow constant pool addresses.  */
1758   if (mode != BLKmode && GET_MODE_SIZE (mode) >= UNITS_PER_WORD
1759       && ! TARGET_CONST16 && constantpool_address_p (addr)
1760       && ! xtensa_tls_referenced_p (addr))
1761     return true;
1762
1763   while (GET_CODE (addr) == SUBREG)
1764     addr = SUBREG_REG (addr);
1765
1766   /* Allow base registers.  */
1767   if (GET_CODE (addr) == REG && BASE_REG_P (addr, strict))
1768     return true;
1769
1770   /* Check for "register + offset" addressing.  */
1771   if (GET_CODE (addr) == PLUS)
1772     {
1773       rtx xplus0 = XEXP (addr, 0);
1774       rtx xplus1 = XEXP (addr, 1);
1775       enum rtx_code code0;
1776       enum rtx_code code1;
1777
1778       while (GET_CODE (xplus0) == SUBREG)
1779         xplus0 = SUBREG_REG (xplus0);
1780       code0 = GET_CODE (xplus0);
1781
1782       while (GET_CODE (xplus1) == SUBREG)
1783         xplus1 = SUBREG_REG (xplus1);
1784       code1 = GET_CODE (xplus1);
1785
1786       /* Swap operands if necessary so the register is first.  */
1787       if (code0 != REG && code1 == REG)
1788         {
1789           xplus0 = XEXP (addr, 1);
1790           xplus1 = XEXP (addr, 0);
1791           code0 = GET_CODE (xplus0);
1792           code1 = GET_CODE (xplus1);
1793         }
1794
1795       if (code0 == REG && BASE_REG_P (xplus0, strict)
1796           && code1 == CONST_INT
1797           && xtensa_mem_offset (INTVAL (xplus1), mode))
1798         return true;
1799     }
1800
1801   return false;
1802 }
1803
1804
1805 /* Construct the SYMBOL_REF for the _TLS_MODULE_BASE_ symbol.  */
1806
1807 static GTY(()) rtx xtensa_tls_module_base_symbol;
1808
1809 static rtx
1810 xtensa_tls_module_base (void)
1811 {
1812   if (! xtensa_tls_module_base_symbol)
1813     {
1814       xtensa_tls_module_base_symbol =
1815         gen_rtx_SYMBOL_REF (Pmode, "_TLS_MODULE_BASE_");
1816       SYMBOL_REF_FLAGS (xtensa_tls_module_base_symbol)
1817         |= TLS_MODEL_GLOBAL_DYNAMIC << SYMBOL_FLAG_TLS_SHIFT;
1818     }
1819
1820   return xtensa_tls_module_base_symbol;
1821 }
1822
1823
1824 static rtx
1825 xtensa_call_tls_desc (rtx sym, rtx *retp)
1826 {
1827   rtx fn, arg, a10, call_insn, insns;
1828
1829   start_sequence ();
1830   fn = gen_reg_rtx (Pmode);
1831   arg = gen_reg_rtx (Pmode);
1832   a10 = gen_rtx_REG (Pmode, 10);
1833
1834   emit_insn (gen_tls_func (fn, sym));
1835   emit_insn (gen_tls_arg (arg, sym));
1836   emit_move_insn (a10, arg);
1837   call_insn = emit_call_insn (gen_tls_call (a10, fn, sym, const1_rtx));
1838   CALL_INSN_FUNCTION_USAGE (call_insn)
1839     = gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_USE (VOIDmode, a10),
1840                          CALL_INSN_FUNCTION_USAGE (call_insn));
1841   insns = get_insns ();
1842   end_sequence ();
1843
1844   *retp = a10;
1845   return insns;
1846 }
1847
1848
1849 static rtx
1850 xtensa_legitimize_tls_address (rtx x)
1851 {
1852   unsigned int model = SYMBOL_REF_TLS_MODEL (x);
1853   rtx dest, tp, ret, modbase, base, addend, insns;
1854
1855   dest = gen_reg_rtx (Pmode);
1856   switch (model)
1857     {
1858     case TLS_MODEL_GLOBAL_DYNAMIC:
1859       insns = xtensa_call_tls_desc (x, &ret);
1860       emit_libcall_block (insns, dest, ret, x);
1861       break;
1862
1863     case TLS_MODEL_LOCAL_DYNAMIC:
1864       base = gen_reg_rtx (Pmode);
1865       modbase = xtensa_tls_module_base ();
1866       insns = xtensa_call_tls_desc (modbase, &ret);
1867       emit_libcall_block (insns, base, ret, modbase);
1868       addend = force_reg (SImode, gen_sym_DTPOFF (x));
1869       emit_insn (gen_addsi3 (dest, base, addend));
1870       break;
1871
1872     case TLS_MODEL_INITIAL_EXEC:
1873     case TLS_MODEL_LOCAL_EXEC:
1874       tp = gen_reg_rtx (SImode);
1875       emit_insn (gen_load_tp (tp));
1876       addend = force_reg (SImode, gen_sym_TPOFF (x));
1877       emit_insn (gen_addsi3 (dest, tp, addend));
1878       break;
1879
1880     default:
1881       gcc_unreachable ();
1882     }
1883
1884   return dest;
1885 }
1886
1887
1888 rtx
1889 xtensa_legitimize_address (rtx x,
1890                            rtx oldx ATTRIBUTE_UNUSED,
1891                            enum machine_mode mode)
1892 {
1893   if (xtensa_tls_symbol_p (x))
1894     return xtensa_legitimize_tls_address (x);
1895
1896   if (GET_CODE (x) == PLUS)
1897     {
1898       rtx plus0 = XEXP (x, 0);
1899       rtx plus1 = XEXP (x, 1);
1900
1901       if (GET_CODE (plus0) != REG && GET_CODE (plus1) == REG)
1902         {
1903           plus0 = XEXP (x, 1);
1904           plus1 = XEXP (x, 0);
1905         }
1906
1907       /* Try to split up the offset to use an ADDMI instruction.  */
1908       if (GET_CODE (plus0) == REG
1909           && GET_CODE (plus1) == CONST_INT
1910           && !xtensa_mem_offset (INTVAL (plus1), mode)
1911           && !xtensa_simm8 (INTVAL (plus1))
1912           && xtensa_mem_offset (INTVAL (plus1) & 0xff, mode)
1913           && xtensa_simm8x256 (INTVAL (plus1) & ~0xff))
1914         {
1915           rtx temp = gen_reg_rtx (Pmode);
1916           rtx addmi_offset = GEN_INT (INTVAL (plus1) & ~0xff);
1917           emit_insn (gen_rtx_SET (Pmode, temp,
1918                                   gen_rtx_PLUS (Pmode, plus0, addmi_offset)));
1919           return gen_rtx_PLUS (Pmode, temp, GEN_INT (INTVAL (plus1) & 0xff));
1920         }
1921     }
1922
1923   return x;
1924 }
1925
1926
1927 /* Helper for xtensa_tls_referenced_p.  */
1928
1929 static int
1930 xtensa_tls_referenced_p_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1931 {
1932   if (GET_CODE (*x) == SYMBOL_REF)
1933     return SYMBOL_REF_TLS_MODEL (*x) != 0;
1934
1935   /* Ignore TLS references that have already been legitimized.  */
1936   if (GET_CODE (*x) == UNSPEC)
1937     {
1938       switch (XINT (*x, 1))
1939         {
1940         case UNSPEC_TPOFF:
1941         case UNSPEC_DTPOFF:
1942         case UNSPEC_TLS_FUNC:
1943         case UNSPEC_TLS_ARG:
1944         case UNSPEC_TLS_CALL:
1945           return -1;
1946         default:
1947           break;
1948         }
1949     }
1950
1951   return 0;
1952 }
1953
1954
1955 /* Return TRUE if X contains any TLS symbol references.  */
1956
1957 bool
1958 xtensa_tls_referenced_p (rtx x)
1959 {
1960   if (! TARGET_HAVE_TLS)
1961     return false;
1962
1963   return for_each_rtx (&x, xtensa_tls_referenced_p_1, NULL);
1964 }
1965
1966
1967 /* Return the debugger register number to use for 'regno'.  */
1968
1969 int
1970 xtensa_dbx_register_number (int regno)
1971 {
1972   int first = -1;
1973
1974   if (GP_REG_P (regno))
1975     {
1976       regno -= GP_REG_FIRST;
1977       first = 0;
1978     }
1979   else if (BR_REG_P (regno))
1980     {
1981       regno -= BR_REG_FIRST;
1982       first = 16;
1983     }
1984   else if (FP_REG_P (regno))
1985     {
1986       regno -= FP_REG_FIRST;
1987       first = 48;
1988     }
1989   else if (ACC_REG_P (regno))
1990     {
1991       first = 0x200;    /* Start of Xtensa special registers.  */
1992       regno = 16;       /* ACCLO is special register 16.  */
1993     }
1994
1995   /* When optimizing, we sometimes get asked about pseudo-registers
1996      that don't represent hard registers.  Return 0 for these.  */
1997   if (first == -1)
1998     return 0;
1999
2000   return first + regno;
2001 }
2002
2003
2004 /* Argument support functions.  */
2005
2006 /* Initialize CUMULATIVE_ARGS for a function.  */
2007
2008 void
2009 init_cumulative_args (CUMULATIVE_ARGS *cum, int incoming)
2010 {
2011   cum->arg_words = 0;
2012   cum->incoming = incoming;
2013 }
2014
2015
2016 /* Advance the argument to the next argument position.  */
2017
2018 static void
2019 xtensa_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2020                              const_tree type, bool named ATTRIBUTE_UNUSED)
2021 {
2022   int words, max;
2023   int *arg_words;
2024
2025   arg_words = &cum->arg_words;
2026   max = MAX_ARGS_IN_REGISTERS;
2027
2028   words = (((mode != BLKmode)
2029             ? (int) GET_MODE_SIZE (mode)
2030             : int_size_in_bytes (type)) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2031
2032   if (*arg_words < max
2033       && (targetm.calls.must_pass_in_stack (mode, type)
2034           || *arg_words + words > max))
2035     *arg_words = max;
2036
2037   *arg_words += words;
2038 }
2039
2040
2041 /* Return an RTL expression containing the register for the given mode,
2042    or 0 if the argument is to be passed on the stack.  INCOMING_P is nonzero
2043    if this is an incoming argument to the current function.  */
2044
2045 static rtx
2046 xtensa_function_arg_1 (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
2047                        const_tree type, bool incoming_p)
2048 {
2049   int regbase, words, max;
2050   int *arg_words;
2051   int regno;
2052
2053   arg_words = &cum->arg_words;
2054   regbase = (incoming_p ? GP_ARG_FIRST : GP_OUTGOING_ARG_FIRST);
2055   max = MAX_ARGS_IN_REGISTERS;
2056
2057   words = (((mode != BLKmode)
2058             ? (int) GET_MODE_SIZE (mode)
2059             : int_size_in_bytes (type)) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2060
2061   if (type && (TYPE_ALIGN (type) > BITS_PER_WORD))
2062     {
2063       int align = MIN (TYPE_ALIGN (type), STACK_BOUNDARY) / BITS_PER_WORD;
2064       *arg_words = (*arg_words + align - 1) & -align;
2065     }
2066
2067   if (*arg_words + words > max)
2068     return (rtx)0;
2069
2070   regno = regbase + *arg_words;
2071
2072   if (cum->incoming && regno <= A7_REG && regno + words > A7_REG)
2073     cfun->machine->need_a7_copy = true;
2074
2075   return gen_rtx_REG (mode, regno);
2076 }
2077
2078 /* Implement TARGET_FUNCTION_ARG.  */
2079
2080 static rtx
2081 xtensa_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2082                      const_tree type, bool named ATTRIBUTE_UNUSED)
2083 {
2084   return xtensa_function_arg_1 (cum, mode, type, false);
2085 }
2086
2087 /* Implement TARGET_FUNCTION_INCOMING_ARG.  */
2088
2089 static rtx
2090 xtensa_function_incoming_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
2091                               const_tree type, bool named ATTRIBUTE_UNUSED)
2092 {
2093   return xtensa_function_arg_1 (cum, mode, type, true);
2094 }
2095
2096 int
2097 function_arg_boundary (enum machine_mode mode, tree type)
2098 {
2099   unsigned int alignment;
2100
2101   alignment = type ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode);
2102   if (alignment < PARM_BOUNDARY)
2103     alignment = PARM_BOUNDARY;
2104   if (alignment > STACK_BOUNDARY)
2105     alignment = STACK_BOUNDARY;
2106   return alignment;
2107 }
2108
2109
2110 static bool
2111 xtensa_return_in_msb (const_tree valtype)
2112 {
2113   return (TARGET_BIG_ENDIAN
2114           && AGGREGATE_TYPE_P (valtype)
2115           && int_size_in_bytes (valtype) >= UNITS_PER_WORD);
2116 }
2117
2118
2119 static void
2120 xtensa_option_override (void)
2121 {
2122   int regno;
2123   enum machine_mode mode;
2124
2125   if (!TARGET_BOOLEANS && TARGET_HARD_FLOAT)
2126     error ("boolean registers required for the floating-point option");
2127
2128   /* Set up array giving whether a given register can hold a given mode.  */
2129   for (mode = VOIDmode;
2130        mode != MAX_MACHINE_MODE;
2131        mode = (enum machine_mode) ((int) mode + 1))
2132     {
2133       int size = GET_MODE_SIZE (mode);
2134       enum mode_class mclass = GET_MODE_CLASS (mode);
2135
2136       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
2137         {
2138           int temp;
2139
2140           if (ACC_REG_P (regno))
2141             temp = (TARGET_MAC16
2142                     && (mclass == MODE_INT) && (size <= UNITS_PER_WORD));
2143           else if (GP_REG_P (regno))
2144             temp = ((regno & 1) == 0 || (size <= UNITS_PER_WORD));
2145           else if (FP_REG_P (regno))
2146             temp = (TARGET_HARD_FLOAT && (mode == SFmode));
2147           else if (BR_REG_P (regno))
2148             temp = (TARGET_BOOLEANS && (mode == CCmode));
2149           else
2150             temp = FALSE;
2151
2152           xtensa_hard_regno_mode_ok[(int) mode][regno] = temp;
2153         }
2154     }
2155
2156   init_machine_status = xtensa_init_machine_status;
2157
2158   /* Check PIC settings.  PIC is only supported when using L32R
2159      instructions, and some targets need to always use PIC.  */
2160   if (flag_pic && TARGET_CONST16)
2161     error ("-f%s is not supported with CONST16 instructions",
2162            (flag_pic > 1 ? "PIC" : "pic"));
2163   else if (TARGET_FORCE_NO_PIC)
2164     flag_pic = 0;
2165   else if (XTENSA_ALWAYS_PIC)
2166     {
2167       if (TARGET_CONST16)
2168         error ("PIC is required but not supported with CONST16 instructions");
2169       flag_pic = 1;
2170     }
2171   /* There's no need for -fPIC (as opposed to -fpic) on Xtensa.  */
2172   if (flag_pic > 1)
2173     flag_pic = 1;
2174   if (flag_pic && !flag_pie)
2175     flag_shlib = 1;
2176
2177   /* Hot/cold partitioning does not work on this architecture, because of
2178      constant pools (the load instruction cannot necessarily reach that far).
2179      Therefore disable it on this architecture.  */
2180   if (flag_reorder_blocks_and_partition)
2181     {
2182       flag_reorder_blocks_and_partition = 0;
2183       flag_reorder_blocks = 1;
2184     }
2185 }
2186
2187 /* A C compound statement to output to stdio stream STREAM the
2188    assembler syntax for an instruction operand X.  X is an RTL
2189    expression.
2190
2191    CODE is a value that can be used to specify one of several ways
2192    of printing the operand.  It is used when identical operands
2193    must be printed differently depending on the context.  CODE
2194    comes from the '%' specification that was used to request
2195    printing of the operand.  If the specification was just '%DIGIT'
2196    then CODE is 0; if the specification was '%LTR DIGIT' then CODE
2197    is the ASCII code for LTR.
2198
2199    If X is a register, this macro should print the register's name.
2200    The names can be found in an array 'reg_names' whose type is
2201    'char *[]'.  'reg_names' is initialized from 'REGISTER_NAMES'.
2202
2203    When the machine description has a specification '%PUNCT' (a '%'
2204    followed by a punctuation character), this macro is called with
2205    a null pointer for X and the punctuation character for CODE.
2206
2207    'a', 'c', 'l', and 'n' are reserved.
2208
2209    The Xtensa specific codes are:
2210
2211    'd'  CONST_INT, print as signed decimal
2212    'x'  CONST_INT, print as signed hexadecimal
2213    'K'  CONST_INT, print number of bits in mask for EXTUI
2214    'R'  CONST_INT, print (X & 0x1f)
2215    'L'  CONST_INT, print ((32 - X) & 0x1f)
2216    'D'  REG, print second register of double-word register operand
2217    'N'  MEM, print address of next word following a memory operand
2218    'v'  MEM, if memory reference is volatile, output a MEMW before it
2219    't'  any constant, add "@h" suffix for top 16 bits
2220    'b'  any constant, add "@l" suffix for bottom 16 bits
2221 */
2222
2223 static void
2224 printx (FILE *file, signed int val)
2225 {
2226   /* Print a hexadecimal value in a nice way.  */
2227   if ((val > -0xa) && (val < 0xa))
2228     fprintf (file, "%d", val);
2229   else if (val < 0)
2230     fprintf (file, "-0x%x", -val);
2231   else
2232     fprintf (file, "0x%x", val);
2233 }
2234
2235
2236 void
2237 print_operand (FILE *file, rtx x, int letter)
2238 {
2239   if (!x)
2240     error ("PRINT_OPERAND null pointer");
2241
2242   switch (letter)
2243     {
2244     case 'D':
2245       if (GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2246         fprintf (file, "%s", reg_names[xt_true_regnum (x) + 1]);
2247       else
2248         output_operand_lossage ("invalid %%D value");
2249       break;
2250
2251     case 'v':
2252       if (GET_CODE (x) == MEM)
2253         {
2254           /* For a volatile memory reference, emit a MEMW before the
2255              load or store.  */
2256           if (MEM_VOLATILE_P (x) && TARGET_SERIALIZE_VOLATILE)
2257             fprintf (file, "memw\n\t");
2258         }
2259       else
2260         output_operand_lossage ("invalid %%v value");
2261       break;
2262
2263     case 'N':
2264       if (GET_CODE (x) == MEM
2265           && (GET_MODE (x) == DFmode || GET_MODE (x) == DImode))
2266         {
2267           x = adjust_address (x, GET_MODE (x) == DFmode ? SFmode : SImode, 4);
2268           output_address (XEXP (x, 0));
2269         }
2270       else
2271         output_operand_lossage ("invalid %%N value");
2272       break;
2273
2274     case 'K':
2275       if (GET_CODE (x) == CONST_INT)
2276         {
2277           int num_bits = 0;
2278           unsigned val = INTVAL (x);
2279           while (val & 1)
2280             {
2281               num_bits += 1;
2282               val = val >> 1;
2283             }
2284           if ((val != 0) || (num_bits == 0) || (num_bits > 16))
2285             fatal_insn ("invalid mask", x);
2286
2287           fprintf (file, "%d", num_bits);
2288         }
2289       else
2290         output_operand_lossage ("invalid %%K value");
2291       break;
2292
2293     case 'L':
2294       if (GET_CODE (x) == CONST_INT)
2295         fprintf (file, "%ld", (32 - INTVAL (x)) & 0x1f);
2296       else
2297         output_operand_lossage ("invalid %%L value");
2298       break;
2299
2300     case 'R':
2301       if (GET_CODE (x) == CONST_INT)
2302         fprintf (file, "%ld", INTVAL (x) & 0x1f);
2303       else
2304         output_operand_lossage ("invalid %%R value");
2305       break;
2306
2307     case 'x':
2308       if (GET_CODE (x) == CONST_INT)
2309         printx (file, INTVAL (x));
2310       else
2311         output_operand_lossage ("invalid %%x value");
2312       break;
2313
2314     case 'd':
2315       if (GET_CODE (x) == CONST_INT)
2316         fprintf (file, "%ld", INTVAL (x));
2317       else
2318         output_operand_lossage ("invalid %%d value");
2319       break;
2320
2321     case 't':
2322     case 'b':
2323       if (GET_CODE (x) == CONST_INT)
2324         {
2325           printx (file, INTVAL (x));
2326           fputs (letter == 't' ? "@h" : "@l", file);
2327         }
2328       else if (GET_CODE (x) == CONST_DOUBLE)
2329         {
2330           REAL_VALUE_TYPE r;
2331           REAL_VALUE_FROM_CONST_DOUBLE (r, x);
2332           if (GET_MODE (x) == SFmode)
2333             {
2334               long l;
2335               REAL_VALUE_TO_TARGET_SINGLE (r, l);
2336               fprintf (file, "0x%08lx@%c", l, letter == 't' ? 'h' : 'l');
2337             }
2338           else
2339             output_operand_lossage ("invalid %%t/%%b value");
2340         }
2341       else if (GET_CODE (x) == CONST)
2342         {
2343           /* X must be a symbolic constant on ELF.  Write an expression
2344              suitable for 'const16' that sets the high or low 16 bits.  */
2345           if (GET_CODE (XEXP (x, 0)) != PLUS
2346               || (GET_CODE (XEXP (XEXP (x, 0), 0)) != SYMBOL_REF
2347                   && GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
2348               || GET_CODE (XEXP (XEXP (x, 0), 1)) != CONST_INT)
2349             output_operand_lossage ("invalid %%t/%%b value");
2350           print_operand (file, XEXP (XEXP (x, 0), 0), 0);
2351           fputs (letter == 't' ? "@h" : "@l", file);
2352           /* There must be a non-alphanumeric character between 'h' or 'l'
2353              and the number.  The '-' is added by print_operand() already.  */
2354           if (INTVAL (XEXP (XEXP (x, 0), 1)) >= 0)
2355             fputs ("+", file);
2356           print_operand (file, XEXP (XEXP (x, 0), 1), 0);
2357         }
2358       else
2359         {
2360           output_addr_const (file, x);
2361           fputs (letter == 't' ? "@h" : "@l", file);
2362         }
2363       break;
2364
2365     default:
2366       if (GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2367         fprintf (file, "%s", reg_names[xt_true_regnum (x)]);
2368       else if (GET_CODE (x) == MEM)
2369         output_address (XEXP (x, 0));
2370       else if (GET_CODE (x) == CONST_INT)
2371         fprintf (file, "%ld", INTVAL (x));
2372       else
2373         output_addr_const (file, x);
2374     }
2375 }
2376
2377
2378 /* A C compound statement to output to stdio stream STREAM the
2379    assembler syntax for an instruction operand that is a memory
2380    reference whose address is ADDR.  ADDR is an RTL expression.  */
2381
2382 void
2383 print_operand_address (FILE *file, rtx addr)
2384 {
2385   if (!addr)
2386     error ("PRINT_OPERAND_ADDRESS, null pointer");
2387
2388   switch (GET_CODE (addr))
2389     {
2390     default:
2391       fatal_insn ("invalid address", addr);
2392       break;
2393
2394     case REG:
2395       fprintf (file, "%s, 0", reg_names [REGNO (addr)]);
2396       break;
2397
2398     case PLUS:
2399       {
2400         rtx reg = (rtx)0;
2401         rtx offset = (rtx)0;
2402         rtx arg0 = XEXP (addr, 0);
2403         rtx arg1 = XEXP (addr, 1);
2404
2405         if (GET_CODE (arg0) == REG)
2406           {
2407             reg = arg0;
2408             offset = arg1;
2409           }
2410         else if (GET_CODE (arg1) == REG)
2411           {
2412             reg = arg1;
2413             offset = arg0;
2414           }
2415         else
2416           fatal_insn ("no register in address", addr);
2417
2418         if (CONSTANT_P (offset))
2419           {
2420             fprintf (file, "%s, ", reg_names [REGNO (reg)]);
2421             output_addr_const (file, offset);
2422           }
2423         else
2424           fatal_insn ("address offset not a constant", addr);
2425       }
2426       break;
2427
2428     case LABEL_REF:
2429     case SYMBOL_REF:
2430     case CONST_INT:
2431     case CONST:
2432       output_addr_const (file, addr);
2433       break;
2434     }
2435 }
2436
2437
2438 bool
2439 xtensa_output_addr_const_extra (FILE *fp, rtx x)
2440 {
2441   if (GET_CODE (x) == UNSPEC && XVECLEN (x, 0) == 1)
2442     {
2443       switch (XINT (x, 1))
2444         {
2445         case UNSPEC_TPOFF:
2446           output_addr_const (fp, XVECEXP (x, 0, 0));
2447           fputs ("@TPOFF", fp);
2448           return true;
2449         case UNSPEC_DTPOFF:
2450           output_addr_const (fp, XVECEXP (x, 0, 0));
2451           fputs ("@DTPOFF", fp);
2452           return true;
2453         case UNSPEC_PLT:
2454           if (flag_pic)
2455             {
2456               output_addr_const (fp, XVECEXP (x, 0, 0));
2457               fputs ("@PLT", fp);
2458               return true;
2459             }
2460           break;
2461         default:
2462           break;
2463         }
2464     }
2465   return false;
2466 }
2467
2468
2469 void
2470 xtensa_output_literal (FILE *file, rtx x, enum machine_mode mode, int labelno)
2471 {
2472   long value_long[2];
2473   REAL_VALUE_TYPE r;
2474   int size;
2475   rtx first, second;
2476
2477   fprintf (file, "\t.literal .LC%u, ", (unsigned) labelno);
2478
2479   switch (GET_MODE_CLASS (mode))
2480     {
2481     case MODE_FLOAT:
2482       gcc_assert (GET_CODE (x) == CONST_DOUBLE);
2483
2484       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
2485       switch (mode)
2486         {
2487         case SFmode:
2488           REAL_VALUE_TO_TARGET_SINGLE (r, value_long[0]);
2489           if (HOST_BITS_PER_LONG > 32)
2490             value_long[0] &= 0xffffffff;
2491           fprintf (file, "0x%08lx\n", value_long[0]);
2492           break;
2493
2494         case DFmode:
2495           REAL_VALUE_TO_TARGET_DOUBLE (r, value_long);
2496           if (HOST_BITS_PER_LONG > 32)
2497             {
2498               value_long[0] &= 0xffffffff;
2499               value_long[1] &= 0xffffffff;
2500             }
2501           fprintf (file, "0x%08lx, 0x%08lx\n",
2502                    value_long[0], value_long[1]);
2503           break;
2504
2505         default:
2506           gcc_unreachable ();
2507         }
2508
2509       break;
2510
2511     case MODE_INT:
2512     case MODE_PARTIAL_INT:
2513       size = GET_MODE_SIZE (mode);
2514       switch (size)
2515         {
2516         case 4:
2517           output_addr_const (file, x);
2518           fputs ("\n", file);
2519           break;
2520
2521         case 8:
2522           split_double (x, &first, &second);
2523           output_addr_const (file, first);
2524           fputs (", ", file);
2525           output_addr_const (file, second);
2526           fputs ("\n", file);
2527           break;
2528
2529         default:
2530           gcc_unreachable ();
2531         }
2532       break;
2533
2534     default:
2535       gcc_unreachable ();
2536     }
2537 }
2538
2539
2540 /* Return the bytes needed to compute the frame pointer from the current
2541    stack pointer.  */
2542
2543 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
2544 #define XTENSA_STACK_ALIGN(LOC) (((LOC) + STACK_BYTES-1) & ~(STACK_BYTES-1))
2545
2546 long
2547 compute_frame_size (int size)
2548 {
2549   /* Add space for the incoming static chain value.  */
2550   if (cfun->static_chain_decl != NULL)
2551     size += (1 * UNITS_PER_WORD);
2552
2553   xtensa_current_frame_size =
2554     XTENSA_STACK_ALIGN (size
2555                         + crtl->outgoing_args_size
2556                         + (WINDOW_SIZE * UNITS_PER_WORD));
2557   return xtensa_current_frame_size;
2558 }
2559
2560
2561 bool
2562 xtensa_frame_pointer_required (void)
2563 {
2564   /* The code to expand builtin_frame_addr and builtin_return_addr
2565      currently uses the hard_frame_pointer instead of frame_pointer.
2566      This seems wrong but maybe it's necessary for other architectures.
2567      This function is derived from the i386 code.  */
2568
2569   if (cfun->machine->accesses_prev_frame)
2570     return true;
2571
2572   return false;
2573 }
2574
2575
2576 /* minimum frame = reg save area (4 words) plus static chain (1 word)
2577    and the total number of words must be a multiple of 128 bits.  */
2578 #define MIN_FRAME_SIZE (8 * UNITS_PER_WORD)
2579
2580 void
2581 xtensa_expand_prologue (void)
2582 {
2583   HOST_WIDE_INT total_size;
2584   rtx size_rtx;
2585   rtx insn, note_rtx;
2586
2587   total_size = compute_frame_size (get_frame_size ());
2588   size_rtx = GEN_INT (total_size);
2589
2590   if (total_size < (1 << (12+3)))
2591     insn = emit_insn (gen_entry (size_rtx));
2592   else
2593     {
2594       /* Use a8 as a temporary since a0-a7 may be live.  */
2595       rtx tmp_reg = gen_rtx_REG (Pmode, A8_REG);
2596       emit_insn (gen_entry (GEN_INT (MIN_FRAME_SIZE)));
2597       emit_move_insn (tmp_reg, GEN_INT (total_size - MIN_FRAME_SIZE));
2598       emit_insn (gen_subsi3 (tmp_reg, stack_pointer_rtx, tmp_reg));
2599       insn = emit_insn (gen_movsi (stack_pointer_rtx, tmp_reg));
2600     }
2601
2602   if (frame_pointer_needed)
2603     {
2604       if (cfun->machine->set_frame_ptr_insn)
2605         {
2606           rtx first;
2607
2608           push_topmost_sequence ();
2609           first = get_insns ();
2610           pop_topmost_sequence ();
2611
2612           /* For all instructions prior to set_frame_ptr_insn, replace
2613              hard_frame_pointer references with stack_pointer.  */
2614           for (insn = first;
2615                insn != cfun->machine->set_frame_ptr_insn;
2616                insn = NEXT_INSN (insn))
2617             {
2618               if (INSN_P (insn))
2619                 {
2620                   PATTERN (insn) = replace_rtx (copy_rtx (PATTERN (insn)),
2621                                                 hard_frame_pointer_rtx,
2622                                                 stack_pointer_rtx);
2623                   df_insn_rescan (insn);
2624                 }
2625             }
2626         }
2627       else
2628         insn = emit_insn (gen_movsi (hard_frame_pointer_rtx,
2629                                      stack_pointer_rtx));
2630     }
2631
2632   /* Create a note to describe the CFA.  Because this is only used to set
2633      DW_AT_frame_base for debug info, don't bother tracking changes through
2634      each instruction in the prologue.  It just takes up space.  */
2635   note_rtx = gen_rtx_SET (VOIDmode, (frame_pointer_needed
2636                                      ? hard_frame_pointer_rtx
2637                                      : stack_pointer_rtx),
2638                           plus_constant (stack_pointer_rtx, -total_size));
2639   RTX_FRAME_RELATED_P (insn) = 1;
2640   REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
2641                                         note_rtx, REG_NOTES (insn));
2642 }
2643
2644
2645 /* Clear variables at function end.  */
2646
2647 void
2648 xtensa_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
2649                           HOST_WIDE_INT size ATTRIBUTE_UNUSED)
2650 {
2651   xtensa_current_frame_size = 0;
2652 }
2653
2654
2655 rtx
2656 xtensa_return_addr (int count, rtx frame)
2657 {
2658   rtx result, retaddr, curaddr, label;
2659
2660   if (count == -1)
2661     retaddr = gen_rtx_REG (Pmode, A0_REG);
2662   else
2663     {
2664       rtx addr = plus_constant (frame, -4 * UNITS_PER_WORD);
2665       addr = memory_address (Pmode, addr);
2666       retaddr = gen_reg_rtx (Pmode);
2667       emit_move_insn (retaddr, gen_rtx_MEM (Pmode, addr));
2668     }
2669
2670   /* The 2 most-significant bits of the return address on Xtensa hold
2671      the register window size.  To get the real return address, these
2672      bits must be replaced with the high bits from some address in the
2673      code.  */
2674
2675   /* Get the 2 high bits of a local label in the code.  */
2676   curaddr = gen_reg_rtx (Pmode);
2677   label = gen_label_rtx ();
2678   emit_label (label);
2679   LABEL_PRESERVE_P (label) = 1;
2680   emit_move_insn (curaddr, gen_rtx_LABEL_REF (Pmode, label));
2681   emit_insn (gen_lshrsi3 (curaddr, curaddr, GEN_INT (30)));
2682   emit_insn (gen_ashlsi3 (curaddr, curaddr, GEN_INT (30)));
2683
2684   /* Clear the 2 high bits of the return address.  */
2685   result = gen_reg_rtx (Pmode);
2686   emit_insn (gen_ashlsi3 (result, retaddr, GEN_INT (2)));
2687   emit_insn (gen_lshrsi3 (result, result, GEN_INT (2)));
2688
2689   /* Combine them to get the result.  */
2690   emit_insn (gen_iorsi3 (result, result, curaddr));
2691   return result;
2692 }
2693
2694
2695 /* Create the va_list data type.
2696
2697    This structure is set up by __builtin_saveregs.  The __va_reg field
2698    points to a stack-allocated region holding the contents of the
2699    incoming argument registers.  The __va_ndx field is an index
2700    initialized to the position of the first unnamed (variable)
2701    argument.  This same index is also used to address the arguments
2702    passed in memory.  Thus, the __va_stk field is initialized to point
2703    to the position of the first argument in memory offset to account
2704    for the arguments passed in registers and to account for the size
2705    of the argument registers not being 16-byte aligned.  E.G., there
2706    are 6 argument registers of 4 bytes each, but we want the __va_ndx
2707    for the first stack argument to have the maximal alignment of 16
2708    bytes, so we offset the __va_stk address by 32 bytes so that
2709    __va_stk[32] references the first argument on the stack.  */
2710
2711 static tree
2712 xtensa_build_builtin_va_list (void)
2713 {
2714   tree f_stk, f_reg, f_ndx, record, type_decl;
2715
2716   record = (*lang_hooks.types.make_type) (RECORD_TYPE);
2717   type_decl = build_decl (BUILTINS_LOCATION,
2718                           TYPE_DECL, get_identifier ("__va_list_tag"), record);
2719
2720   f_stk = build_decl (BUILTINS_LOCATION,
2721                       FIELD_DECL, get_identifier ("__va_stk"),
2722                       ptr_type_node);
2723   f_reg = build_decl (BUILTINS_LOCATION,
2724                       FIELD_DECL, get_identifier ("__va_reg"),
2725                       ptr_type_node);
2726   f_ndx = build_decl (BUILTINS_LOCATION,
2727                       FIELD_DECL, get_identifier ("__va_ndx"),
2728                       integer_type_node);
2729
2730   DECL_FIELD_CONTEXT (f_stk) = record;
2731   DECL_FIELD_CONTEXT (f_reg) = record;
2732   DECL_FIELD_CONTEXT (f_ndx) = record;
2733
2734   TYPE_STUB_DECL (record) = type_decl;
2735   TYPE_NAME (record) = type_decl;
2736   TYPE_FIELDS (record) = f_stk;
2737   DECL_CHAIN (f_stk) = f_reg;
2738   DECL_CHAIN (f_reg) = f_ndx;
2739
2740   layout_type (record);
2741   return record;
2742 }
2743
2744
2745 /* Save the incoming argument registers on the stack.  Returns the
2746    address of the saved registers.  */
2747
2748 static rtx
2749 xtensa_builtin_saveregs (void)
2750 {
2751   rtx gp_regs;
2752   int arg_words = crtl->args.info.arg_words;
2753   int gp_left = MAX_ARGS_IN_REGISTERS - arg_words;
2754
2755   if (gp_left <= 0)
2756     return const0_rtx;
2757
2758   /* Allocate the general-purpose register space.  */
2759   gp_regs = assign_stack_local
2760     (BLKmode, MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD, -1);
2761   set_mem_alias_set (gp_regs, get_varargs_alias_set ());
2762
2763   /* Now store the incoming registers.  */
2764   cfun->machine->need_a7_copy = true;
2765   cfun->machine->vararg_a7 = true;
2766   move_block_from_reg (GP_ARG_FIRST + arg_words,
2767                        adjust_address (gp_regs, BLKmode,
2768                                        arg_words * UNITS_PER_WORD),
2769                        gp_left);
2770   gcc_assert (cfun->machine->vararg_a7_copy != 0);
2771   emit_insn_before (cfun->machine->vararg_a7_copy, get_insns ());
2772
2773   return XEXP (gp_regs, 0);
2774 }
2775
2776
2777 /* Implement `va_start' for varargs and stdarg.  We look at the
2778    current function to fill in an initial va_list.  */
2779
2780 static void
2781 xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
2782 {
2783   tree f_stk, stk;
2784   tree f_reg, reg;
2785   tree f_ndx, ndx;
2786   tree t, u;
2787   int arg_words;
2788
2789   arg_words = crtl->args.info.arg_words;
2790
2791   f_stk = TYPE_FIELDS (va_list_type_node);
2792   f_reg = DECL_CHAIN (f_stk);
2793   f_ndx = DECL_CHAIN (f_reg);
2794
2795   stk = build3 (COMPONENT_REF, TREE_TYPE (f_stk), valist, f_stk, NULL_TREE);
2796   reg = build3 (COMPONENT_REF, TREE_TYPE (f_reg), unshare_expr (valist),
2797                 f_reg, NULL_TREE);
2798   ndx = build3 (COMPONENT_REF, TREE_TYPE (f_ndx), unshare_expr (valist),
2799                 f_ndx, NULL_TREE);
2800
2801   /* Call __builtin_saveregs; save the result in __va_reg */
2802   u = make_tree (sizetype, expand_builtin_saveregs ());
2803   u = fold_convert (ptr_type_node, u);
2804   t = build2 (MODIFY_EXPR, ptr_type_node, reg, u);
2805   TREE_SIDE_EFFECTS (t) = 1;
2806   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2807
2808   /* Set the __va_stk member to ($arg_ptr - 32).  */
2809   u = make_tree (ptr_type_node, virtual_incoming_args_rtx);
2810   u = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, u, size_int (-32));
2811   t = build2 (MODIFY_EXPR, ptr_type_node, stk, u);
2812   TREE_SIDE_EFFECTS (t) = 1;
2813   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2814
2815   /* Set the __va_ndx member.  If the first variable argument is on
2816      the stack, adjust __va_ndx by 2 words to account for the extra
2817      alignment offset for __va_stk.  */
2818   if (arg_words >= MAX_ARGS_IN_REGISTERS)
2819     arg_words += 2;
2820   t = build2 (MODIFY_EXPR, integer_type_node, ndx,
2821               build_int_cst (integer_type_node, arg_words * UNITS_PER_WORD));
2822   TREE_SIDE_EFFECTS (t) = 1;
2823   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2824 }
2825
2826
2827 /* Implement `va_arg'.  */
2828
2829 static tree
2830 xtensa_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
2831                              gimple_seq *post_p ATTRIBUTE_UNUSED)
2832 {
2833   tree f_stk, stk;
2834   tree f_reg, reg;
2835   tree f_ndx, ndx;
2836   tree type_size, array, orig_ndx, addr, size, va_size, t;
2837   tree lab_false, lab_over, lab_false2;
2838   bool indirect;
2839
2840   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
2841   if (indirect)
2842     type = build_pointer_type (type);
2843
2844   /* Handle complex values as separate real and imaginary parts.  */
2845   if (TREE_CODE (type) == COMPLEX_TYPE)
2846     {
2847       tree real_part, imag_part;
2848
2849       real_part = xtensa_gimplify_va_arg_expr (valist, TREE_TYPE (type),
2850                                                pre_p, NULL);
2851       real_part = get_initialized_tmp_var (real_part, pre_p, NULL);
2852
2853       imag_part = xtensa_gimplify_va_arg_expr (unshare_expr (valist),
2854                                                TREE_TYPE (type),
2855                                                pre_p, NULL);
2856       imag_part = get_initialized_tmp_var (imag_part, pre_p, NULL);
2857
2858       return build2 (COMPLEX_EXPR, type, real_part, imag_part);
2859     }
2860
2861   f_stk = TYPE_FIELDS (va_list_type_node);
2862   f_reg = DECL_CHAIN (f_stk);
2863   f_ndx = DECL_CHAIN (f_reg);
2864
2865   stk = build3 (COMPONENT_REF, TREE_TYPE (f_stk), valist,
2866                 f_stk, NULL_TREE);
2867   reg = build3 (COMPONENT_REF, TREE_TYPE (f_reg), unshare_expr (valist),
2868                 f_reg, NULL_TREE);
2869   ndx = build3 (COMPONENT_REF, TREE_TYPE (f_ndx), unshare_expr (valist),
2870                 f_ndx, NULL_TREE);
2871
2872   type_size = size_in_bytes (type);
2873   va_size = round_up (type_size, UNITS_PER_WORD);
2874   gimplify_expr (&va_size, pre_p, NULL, is_gimple_val, fb_rvalue);
2875
2876
2877   /* First align __va_ndx if necessary for this arg:
2878
2879      orig_ndx = (AP).__va_ndx;
2880      if (__alignof__ (TYPE) > 4 )
2881        orig_ndx = ((orig_ndx + __alignof__ (TYPE) - 1)
2882                         & -__alignof__ (TYPE)); */
2883
2884   orig_ndx = get_initialized_tmp_var (ndx, pre_p, NULL);
2885
2886   if (TYPE_ALIGN (type) > BITS_PER_WORD)
2887     {
2888       int align = MIN (TYPE_ALIGN (type), STACK_BOUNDARY) / BITS_PER_UNIT;
2889
2890       t = build2 (PLUS_EXPR, integer_type_node, unshare_expr (orig_ndx),
2891                   build_int_cst (integer_type_node, align - 1));
2892       t = build2 (BIT_AND_EXPR, integer_type_node, t,
2893                   build_int_cst (integer_type_node, -align));
2894       gimplify_assign (unshare_expr (orig_ndx), t, pre_p);
2895     }
2896
2897
2898   /* Increment __va_ndx to point past the argument:
2899
2900      (AP).__va_ndx = orig_ndx + __va_size (TYPE); */
2901
2902   t = fold_convert (integer_type_node, va_size);
2903   t = build2 (PLUS_EXPR, integer_type_node, orig_ndx, t);
2904   gimplify_assign (unshare_expr (ndx), t, pre_p);
2905
2906
2907   /* Check if the argument is in registers:
2908
2909      if ((AP).__va_ndx <= __MAX_ARGS_IN_REGISTERS * 4
2910          && !must_pass_in_stack (type))
2911         __array = (AP).__va_reg; */
2912
2913   array = create_tmp_var (ptr_type_node, NULL);
2914
2915   lab_over = NULL;
2916   if (!targetm.calls.must_pass_in_stack (TYPE_MODE (type), type))
2917     {
2918       lab_false = create_artificial_label (UNKNOWN_LOCATION);
2919       lab_over = create_artificial_label (UNKNOWN_LOCATION);
2920
2921       t = build2 (GT_EXPR, boolean_type_node, unshare_expr (ndx),
2922                   build_int_cst (integer_type_node,
2923                                  MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD));
2924       t = build3 (COND_EXPR, void_type_node, t,
2925                   build1 (GOTO_EXPR, void_type_node, lab_false),
2926                   NULL_TREE);
2927       gimplify_and_add (t, pre_p);
2928
2929       gimplify_assign (unshare_expr (array), reg, pre_p);
2930
2931       t = build1 (GOTO_EXPR, void_type_node, lab_over);
2932       gimplify_and_add (t, pre_p);
2933
2934       t = build1 (LABEL_EXPR, void_type_node, lab_false);
2935       gimplify_and_add (t, pre_p);
2936     }
2937
2938
2939   /* ...otherwise, the argument is on the stack (never split between
2940      registers and the stack -- change __va_ndx if necessary):
2941
2942      else
2943        {
2944          if (orig_ndx <= __MAX_ARGS_IN_REGISTERS * 4)
2945              (AP).__va_ndx = 32 + __va_size (TYPE);
2946          __array = (AP).__va_stk;
2947        } */
2948
2949   lab_false2 = create_artificial_label (UNKNOWN_LOCATION);
2950
2951   t = build2 (GT_EXPR, boolean_type_node, unshare_expr (orig_ndx),
2952               build_int_cst (integer_type_node,
2953                              MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD));
2954   t = build3 (COND_EXPR, void_type_node, t,
2955               build1 (GOTO_EXPR, void_type_node, lab_false2),
2956               NULL_TREE);
2957   gimplify_and_add (t, pre_p);
2958
2959   t = size_binop (PLUS_EXPR, unshare_expr (va_size), size_int (32));
2960   t = fold_convert (integer_type_node, t);
2961   gimplify_assign (unshare_expr (ndx), t, pre_p);
2962
2963   t = build1 (LABEL_EXPR, void_type_node, lab_false2);
2964   gimplify_and_add (t, pre_p);
2965
2966   gimplify_assign (array, stk, pre_p);
2967
2968   if (lab_over)
2969     {
2970       t = build1 (LABEL_EXPR, void_type_node, lab_over);
2971       gimplify_and_add (t, pre_p);
2972     }
2973
2974
2975   /* Given the base array pointer (__array) and index to the subsequent
2976      argument (__va_ndx), find the address:
2977
2978      __array + (AP).__va_ndx - (BYTES_BIG_ENDIAN && sizeof (TYPE) < 4
2979                                 ? sizeof (TYPE)
2980                                 : __va_size (TYPE))
2981
2982      The results are endian-dependent because values smaller than one word
2983      are aligned differently.  */
2984
2985
2986   if (BYTES_BIG_ENDIAN && TREE_CODE (type_size) == INTEGER_CST)
2987     {
2988       t = fold_build2 (GE_EXPR, boolean_type_node, unshare_expr (type_size),
2989                        size_int (PARM_BOUNDARY / BITS_PER_UNIT));
2990       t = fold_build3 (COND_EXPR, sizetype, t, unshare_expr (va_size),
2991                        unshare_expr (type_size));
2992       size = t;
2993     }
2994   else
2995     size = unshare_expr (va_size);
2996
2997   t = fold_convert (sizetype, unshare_expr (ndx));
2998   t = build2 (MINUS_EXPR, sizetype, t, size);
2999   addr = build2 (POINTER_PLUS_EXPR, ptr_type_node, unshare_expr (array), t);
3000
3001   addr = fold_convert (build_pointer_type (type), addr);
3002   if (indirect)
3003     addr = build_va_arg_indirect_ref (addr);
3004   return build_va_arg_indirect_ref (addr);
3005 }
3006
3007
3008 /* Builtins.  */
3009
3010 enum xtensa_builtin
3011 {
3012   XTENSA_BUILTIN_UMULSIDI3,
3013   XTENSA_BUILTIN_THREAD_POINTER,
3014   XTENSA_BUILTIN_SET_THREAD_POINTER,
3015   XTENSA_BUILTIN_max
3016 };
3017
3018
3019 static void
3020 xtensa_init_builtins (void)
3021 {
3022   tree ftype, decl;
3023
3024   ftype = build_function_type_list (unsigned_intDI_type_node,
3025                                     unsigned_intSI_type_node,
3026                                     unsigned_intSI_type_node, NULL_TREE);
3027
3028   decl = add_builtin_function ("__builtin_umulsidi3", ftype,
3029                                XTENSA_BUILTIN_UMULSIDI3, BUILT_IN_MD,
3030                                "__umulsidi3", NULL_TREE);
3031   TREE_NOTHROW (decl) = 1;
3032   TREE_READONLY (decl) = 1;
3033
3034   if (TARGET_THREADPTR)
3035     {
3036       ftype = build_function_type (ptr_type_node, void_list_node);
3037       decl = add_builtin_function ("__builtin_thread_pointer", ftype,
3038                                    XTENSA_BUILTIN_THREAD_POINTER, BUILT_IN_MD,
3039                                    NULL, NULL_TREE);
3040       TREE_READONLY (decl) = 1;
3041       TREE_NOTHROW (decl) = 1;
3042
3043       ftype = build_function_type_list (void_type_node, ptr_type_node,
3044                                         NULL_TREE);
3045       decl = add_builtin_function ("__builtin_set_thread_pointer", ftype,
3046                                    XTENSA_BUILTIN_SET_THREAD_POINTER,
3047                                    BUILT_IN_MD, NULL, NULL_TREE);
3048       TREE_NOTHROW (decl) = 1;
3049     }
3050 }
3051
3052
3053 static tree
3054 xtensa_fold_builtin (tree fndecl, int n_args ATTRIBUTE_UNUSED, tree *args,
3055                      bool ignore ATTRIBUTE_UNUSED)
3056 {
3057   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
3058   tree arg0, arg1;
3059
3060   switch (fcode)
3061     {
3062     case XTENSA_BUILTIN_UMULSIDI3:
3063       arg0 = args[0];
3064       arg1 = args[1];
3065       if ((TREE_CODE (arg0) == INTEGER_CST && TREE_CODE (arg1) == INTEGER_CST)
3066           || TARGET_MUL32_HIGH)
3067         return fold_build2 (MULT_EXPR, unsigned_intDI_type_node,
3068                             fold_convert (unsigned_intDI_type_node, arg0),
3069                             fold_convert (unsigned_intDI_type_node, arg1));
3070       break;
3071
3072     case XTENSA_BUILTIN_THREAD_POINTER:
3073     case XTENSA_BUILTIN_SET_THREAD_POINTER:
3074       break;
3075
3076     default:
3077       internal_error ("bad builtin code");
3078       break;
3079     }
3080
3081   return NULL;
3082 }
3083
3084
3085 static rtx
3086 xtensa_expand_builtin (tree exp, rtx target,
3087                        rtx subtarget ATTRIBUTE_UNUSED,
3088                        enum machine_mode mode ATTRIBUTE_UNUSED,
3089                        int ignore)
3090 {
3091   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
3092   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
3093   rtx arg;
3094
3095   switch (fcode)
3096     {
3097     case XTENSA_BUILTIN_UMULSIDI3:
3098       /* The umulsidi3 builtin is just a mechanism to avoid calling the real
3099          __umulsidi3 function when the Xtensa configuration can directly
3100          implement it.  If not, just call the function.  */
3101       return expand_call (exp, target, ignore);
3102
3103     case XTENSA_BUILTIN_THREAD_POINTER:
3104       if (!target || !register_operand (target, Pmode))
3105         target = gen_reg_rtx (Pmode);
3106       emit_insn (gen_load_tp (target));
3107       return target;
3108
3109     case XTENSA_BUILTIN_SET_THREAD_POINTER:
3110       arg = expand_normal (CALL_EXPR_ARG (exp, 0));
3111       if (!register_operand (arg, Pmode))
3112         arg = copy_to_mode_reg (Pmode, arg);
3113       emit_insn (gen_set_tp (arg));
3114       return const0_rtx;
3115
3116     default:
3117       internal_error ("bad builtin code");
3118     }
3119   return NULL_RTX;
3120 }
3121
3122
3123 enum reg_class
3124 xtensa_preferred_reload_class (rtx x, enum reg_class rclass, int isoutput)
3125 {
3126   if (!isoutput && CONSTANT_P (x) && GET_CODE (x) == CONST_DOUBLE)
3127     return NO_REGS;
3128
3129   /* Don't use the stack pointer or hard frame pointer for reloads!
3130      The hard frame pointer would normally be OK except that it may
3131      briefly hold an incoming argument in the prologue, and reload
3132      won't know that it is live because the hard frame pointer is
3133      treated specially.  */
3134
3135   if (rclass == AR_REGS || rclass == GR_REGS)
3136     return RL_REGS;
3137
3138   return rclass;
3139 }
3140
3141
3142 reg_class_t
3143 xtensa_secondary_reload (bool in_p, rtx x, reg_class_t rclass,
3144                          enum machine_mode mode, secondary_reload_info *sri)
3145 {
3146   int regno;
3147
3148   if (in_p && constantpool_mem_p (x))
3149     {
3150       if (rclass == FP_REGS)
3151         return RL_REGS;
3152
3153       if (mode == QImode)
3154         sri->icode = CODE_FOR_reloadqi_literal;
3155       else if (mode == HImode)
3156         sri->icode = CODE_FOR_reloadhi_literal;
3157     }
3158
3159   regno = xt_true_regnum (x);
3160   if (ACC_REG_P (regno))
3161     return ((rclass == GR_REGS || rclass == RL_REGS) ? NO_REGS : RL_REGS);
3162   if (rclass == ACC_REG)
3163     return (GP_REG_P (regno) ? NO_REGS : RL_REGS);
3164
3165   return NO_REGS;
3166 }
3167
3168
3169 void
3170 order_regs_for_local_alloc (void)
3171 {
3172   if (!leaf_function_p ())
3173     {
3174       memcpy (reg_alloc_order, reg_nonleaf_alloc_order,
3175               FIRST_PSEUDO_REGISTER * sizeof (int));
3176     }
3177   else
3178     {
3179       int i, num_arg_regs;
3180       int nxt = 0;
3181
3182       /* Use the AR registers in increasing order (skipping a0 and a1)
3183          but save the incoming argument registers for a last resort.  */
3184       num_arg_regs = crtl->args.info.arg_words;
3185       if (num_arg_regs > MAX_ARGS_IN_REGISTERS)
3186         num_arg_regs = MAX_ARGS_IN_REGISTERS;
3187       for (i = GP_ARG_FIRST; i < 16 - num_arg_regs; i++)
3188         reg_alloc_order[nxt++] = i + num_arg_regs;
3189       for (i = 0; i < num_arg_regs; i++)
3190         reg_alloc_order[nxt++] = GP_ARG_FIRST + i;
3191
3192       /* List the coprocessor registers in order.  */
3193       for (i = 0; i < BR_REG_NUM; i++)
3194         reg_alloc_order[nxt++] = BR_REG_FIRST + i;
3195
3196       /* List the FP registers in order for now.  */
3197       for (i = 0; i < 16; i++)
3198         reg_alloc_order[nxt++] = FP_REG_FIRST + i;
3199
3200       /* GCC requires that we list *all* the registers....  */
3201       reg_alloc_order[nxt++] = 0;       /* a0 = return address */
3202       reg_alloc_order[nxt++] = 1;       /* a1 = stack pointer */
3203       reg_alloc_order[nxt++] = 16;      /* pseudo frame pointer */
3204       reg_alloc_order[nxt++] = 17;      /* pseudo arg pointer */
3205
3206       reg_alloc_order[nxt++] = ACC_REG_FIRST;   /* MAC16 accumulator */
3207     }
3208 }
3209
3210
3211 /* Some Xtensa targets support multiple bss sections.  If the section
3212    name ends with ".bss", add SECTION_BSS to the flags.  */
3213
3214 static unsigned int
3215 xtensa_multibss_section_type_flags (tree decl, const char *name, int reloc)
3216 {
3217   unsigned int flags = default_section_type_flags (decl, name, reloc);
3218   const char *suffix;
3219
3220   suffix = strrchr (name, '.');
3221   if (suffix && strcmp (suffix, ".bss") == 0)
3222     {
3223       if (!decl || (TREE_CODE (decl) == VAR_DECL
3224                     && DECL_INITIAL (decl) == NULL_TREE))
3225         flags |= SECTION_BSS;  /* @nobits */
3226       else
3227         warning (0, "only uninitialized variables can be placed in a "
3228                  ".bss section");
3229     }
3230
3231   return flags;
3232 }
3233
3234
3235 /* The literal pool stays with the function.  */
3236
3237 static section *
3238 xtensa_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
3239                            rtx x ATTRIBUTE_UNUSED,
3240                            unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
3241 {
3242   return function_section (current_function_decl);
3243 }
3244
3245
3246 /* Compute a (partial) cost for rtx X.  Return true if the complete
3247    cost has been computed, and false if subexpressions should be
3248    scanned.  In either case, *TOTAL contains the cost result.  */
3249
3250 static bool
3251 xtensa_rtx_costs (rtx x, int code, int outer_code, int *total,
3252                   bool speed ATTRIBUTE_UNUSED)
3253 {
3254   switch (code)
3255     {
3256     case CONST_INT:
3257       switch (outer_code)
3258         {
3259         case SET:
3260           if (xtensa_simm12b (INTVAL (x)))
3261             {
3262               *total = 4;
3263               return true;
3264             }
3265           break;
3266         case PLUS:
3267           if (xtensa_simm8 (INTVAL (x))
3268               || xtensa_simm8x256 (INTVAL (x)))
3269             {
3270               *total = 0;
3271               return true;
3272             }
3273           break;
3274         case AND:
3275           if (xtensa_mask_immediate (INTVAL (x)))
3276             {
3277               *total = 0;
3278               return true;
3279             }
3280           break;
3281         case COMPARE:
3282           if ((INTVAL (x) == 0) || xtensa_b4const (INTVAL (x)))
3283             {
3284               *total = 0;
3285               return true;
3286             }
3287           break;
3288         case ASHIFT:
3289         case ASHIFTRT:
3290         case LSHIFTRT:
3291         case ROTATE:
3292         case ROTATERT:
3293           /* No way to tell if X is the 2nd operand so be conservative.  */
3294         default: break;
3295         }
3296       if (xtensa_simm12b (INTVAL (x)))
3297         *total = 5;
3298       else if (TARGET_CONST16)
3299         *total = COSTS_N_INSNS (2);
3300       else
3301         *total = 6;
3302       return true;
3303
3304     case CONST:
3305     case LABEL_REF:
3306     case SYMBOL_REF:
3307       if (TARGET_CONST16)
3308         *total = COSTS_N_INSNS (2);
3309       else
3310         *total = 5;
3311       return true;
3312
3313     case CONST_DOUBLE:
3314       if (TARGET_CONST16)
3315         *total = COSTS_N_INSNS (4);
3316       else
3317         *total = 7;
3318       return true;
3319
3320     case MEM:
3321       {
3322         int num_words =
3323           (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD) ?  2 : 1;
3324
3325         if (memory_address_p (GET_MODE (x), XEXP ((x), 0)))
3326           *total = COSTS_N_INSNS (num_words);
3327         else
3328           *total = COSTS_N_INSNS (2*num_words);
3329         return true;
3330       }
3331
3332     case FFS:
3333     case CTZ:
3334       *total = COSTS_N_INSNS (TARGET_NSA ? 5 : 50);
3335       return true;
3336
3337     case CLZ:
3338       *total = COSTS_N_INSNS (TARGET_NSA ? 1 : 50);
3339       return true;
3340
3341     case NOT:
3342       *total = COSTS_N_INSNS ((GET_MODE (x) == DImode) ? 3 : 2);
3343       return true;
3344
3345     case AND:
3346     case IOR:
3347     case XOR:
3348       if (GET_MODE (x) == DImode)
3349         *total = COSTS_N_INSNS (2);
3350       else
3351         *total = COSTS_N_INSNS (1);
3352       return true;
3353
3354     case ASHIFT:
3355     case ASHIFTRT:
3356     case LSHIFTRT:
3357       if (GET_MODE (x) == DImode)
3358         *total = COSTS_N_INSNS (50);
3359       else
3360         *total = COSTS_N_INSNS (1);
3361       return true;
3362
3363     case ABS:
3364       {
3365         enum machine_mode xmode = GET_MODE (x);
3366         if (xmode == SFmode)
3367           *total = COSTS_N_INSNS (TARGET_HARD_FLOAT ? 1 : 50);
3368         else if (xmode == DFmode)
3369           *total = COSTS_N_INSNS (50);
3370         else
3371           *total = COSTS_N_INSNS (4);
3372         return true;
3373       }
3374
3375     case PLUS:
3376     case MINUS:
3377       {
3378         enum machine_mode xmode = GET_MODE (x);
3379         if (xmode == SFmode)
3380           *total = COSTS_N_INSNS (TARGET_HARD_FLOAT ? 1 : 50);
3381         else if (xmode == DFmode || xmode == DImode)
3382           *total = COSTS_N_INSNS (50);
3383         else
3384           *total = COSTS_N_INSNS (1);
3385         return true;
3386       }
3387
3388     case NEG:
3389       *total = COSTS_N_INSNS ((GET_MODE (x) == DImode) ? 4 : 2);
3390       return true;
3391
3392     case MULT:
3393       {
3394         enum machine_mode xmode = GET_MODE (x);
3395         if (xmode == SFmode)
3396           *total = COSTS_N_INSNS (TARGET_HARD_FLOAT ? 4 : 50);
3397         else if (xmode == DFmode)
3398           *total = COSTS_N_INSNS (50);
3399         else if (xmode == DImode)
3400           *total = COSTS_N_INSNS (TARGET_MUL32_HIGH ? 10 : 50);
3401         else if (TARGET_MUL32)
3402           *total = COSTS_N_INSNS (4);
3403         else if (TARGET_MAC16)
3404           *total = COSTS_N_INSNS (16);
3405         else if (TARGET_MUL16)
3406           *total = COSTS_N_INSNS (12);
3407         else
3408           *total = COSTS_N_INSNS (50);
3409         return true;
3410       }
3411
3412     case DIV:
3413     case MOD:
3414       {
3415         enum machine_mode xmode = GET_MODE (x);
3416         if (xmode == SFmode)
3417           {
3418             *total = COSTS_N_INSNS (TARGET_HARD_FLOAT_DIV ? 8 : 50);
3419             return true;
3420           }
3421         else if (xmode == DFmode)
3422           {
3423             *total = COSTS_N_INSNS (50);
3424             return true;
3425           }
3426       }
3427       /* Fall through.  */
3428
3429     case UDIV:
3430     case UMOD:
3431       {
3432         enum machine_mode xmode = GET_MODE (x);
3433         if (xmode == DImode)
3434           *total = COSTS_N_INSNS (50);
3435         else if (TARGET_DIV32)
3436           *total = COSTS_N_INSNS (32);
3437         else
3438           *total = COSTS_N_INSNS (50);
3439         return true;
3440       }
3441
3442     case SQRT:
3443       if (GET_MODE (x) == SFmode)
3444         *total = COSTS_N_INSNS (TARGET_HARD_FLOAT_SQRT ? 8 : 50);
3445       else
3446         *total = COSTS_N_INSNS (50);
3447       return true;
3448
3449     case SMIN:
3450     case UMIN:
3451     case SMAX:
3452     case UMAX:
3453       *total = COSTS_N_INSNS (TARGET_MINMAX ? 1 : 50);
3454       return true;
3455
3456     case SIGN_EXTRACT:
3457     case SIGN_EXTEND:
3458       *total = COSTS_N_INSNS (TARGET_SEXT ? 1 : 2);
3459       return true;
3460
3461     case ZERO_EXTRACT:
3462     case ZERO_EXTEND:
3463       *total = COSTS_N_INSNS (1);
3464       return true;
3465
3466     default:
3467       return false;
3468     }
3469 }
3470
3471 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
3472
3473 static bool
3474 xtensa_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
3475 {
3476   return ((unsigned HOST_WIDE_INT) int_size_in_bytes (type)
3477           > 4 * UNITS_PER_WORD);
3478 }
3479
3480 /* Worker function for TARGET_FUNCTION_VALUE.  */
3481
3482 rtx
3483 xtensa_function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED,
3484                       bool outgoing)
3485 {
3486   return gen_rtx_REG ((INTEGRAL_TYPE_P (valtype)
3487                       && TYPE_PRECISION (valtype) < BITS_PER_WORD)
3488                      ? SImode : TYPE_MODE (valtype),
3489                      outgoing ? GP_OUTGOING_RETURN : GP_RETURN);
3490 }
3491
3492 /* The static chain is passed in memory.  Provide rtx giving 'mem'
3493    expressions that denote where they are stored.  */
3494
3495 static rtx
3496 xtensa_static_chain (const_tree ARG_UNUSED (fndecl), bool incoming_p)
3497 {
3498   rtx base = incoming_p ? arg_pointer_rtx : stack_pointer_rtx;
3499   return gen_frame_mem (Pmode, plus_constant (base, -5 * UNITS_PER_WORD));
3500 }
3501
3502
3503 /* TRAMPOLINE_TEMPLATE: For Xtensa, the trampoline must perform an ENTRY
3504    instruction with a minimal stack frame in order to get some free
3505    registers.  Once the actual call target is known, the proper stack frame
3506    size is extracted from the ENTRY instruction at the target and the
3507    current frame is adjusted to match.  The trampoline then transfers
3508    control to the instruction following the ENTRY at the target.  Note:
3509    this assumes that the target begins with an ENTRY instruction.  */
3510
3511 static void
3512 xtensa_asm_trampoline_template (FILE *stream)
3513 {
3514   bool use_call0 = (TARGET_CONST16 || TARGET_ABSOLUTE_LITERALS);
3515
3516   fprintf (stream, "\t.begin no-transform\n");
3517   fprintf (stream, "\tentry\tsp, %d\n", MIN_FRAME_SIZE);
3518
3519   if (use_call0)
3520     {
3521       /* Save the return address.  */
3522       fprintf (stream, "\tmov\ta10, a0\n");
3523
3524       /* Use a CALL0 instruction to skip past the constants and in the
3525          process get the PC into A0.  This allows PC-relative access to
3526          the constants without relying on L32R.  */
3527       fprintf (stream, "\tcall0\t.Lskipconsts\n");
3528     }
3529   else
3530     fprintf (stream, "\tj\t.Lskipconsts\n");
3531
3532   fprintf (stream, "\t.align\t4\n");
3533   fprintf (stream, ".Lchainval:%s0\n", integer_asm_op (4, TRUE));
3534   fprintf (stream, ".Lfnaddr:%s0\n", integer_asm_op (4, TRUE));
3535   fprintf (stream, ".Lskipconsts:\n");
3536
3537   /* Load the static chain and function address from the trampoline.  */
3538   if (use_call0)
3539     {
3540       fprintf (stream, "\taddi\ta0, a0, 3\n");
3541       fprintf (stream, "\tl32i\ta9, a0, 0\n");
3542       fprintf (stream, "\tl32i\ta8, a0, 4\n");
3543     }
3544   else
3545     {
3546       fprintf (stream, "\tl32r\ta9, .Lchainval\n");
3547       fprintf (stream, "\tl32r\ta8, .Lfnaddr\n");
3548     }
3549
3550   /* Store the static chain.  */
3551   fprintf (stream, "\ts32i\ta9, sp, %d\n", MIN_FRAME_SIZE - 20);
3552
3553   /* Set the proper stack pointer value.  */
3554   fprintf (stream, "\tl32i\ta9, a8, 0\n");
3555   fprintf (stream, "\textui\ta9, a9, %d, 12\n",
3556            TARGET_BIG_ENDIAN ? 8 : 12);
3557   fprintf (stream, "\tslli\ta9, a9, 3\n");
3558   fprintf (stream, "\taddi\ta9, a9, %d\n", -MIN_FRAME_SIZE);
3559   fprintf (stream, "\tsub\ta9, sp, a9\n");
3560   fprintf (stream, "\tmovsp\tsp, a9\n");
3561
3562   if (use_call0)
3563     /* Restore the return address.  */
3564     fprintf (stream, "\tmov\ta0, a10\n");
3565
3566   /* Jump to the instruction following the ENTRY.  */
3567   fprintf (stream, "\taddi\ta8, a8, 3\n");
3568   fprintf (stream, "\tjx\ta8\n");
3569
3570   /* Pad size to a multiple of TRAMPOLINE_ALIGNMENT.  */
3571   if (use_call0)
3572     fprintf (stream, "\t.byte\t0\n");
3573   else
3574     fprintf (stream, "\tnop\n");
3575
3576   fprintf (stream, "\t.end no-transform\n");
3577 }
3578
3579 static void
3580 xtensa_trampoline_init (rtx m_tramp, tree fndecl, rtx chain)
3581 {
3582   rtx func = XEXP (DECL_RTL (fndecl), 0);
3583   bool use_call0 = (TARGET_CONST16 || TARGET_ABSOLUTE_LITERALS);
3584   int chain_off = use_call0 ? 12 : 8;
3585   int func_off = use_call0 ? 16 : 12;
3586
3587   emit_block_move (m_tramp, assemble_trampoline_template (),
3588                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
3589
3590   emit_move_insn (adjust_address (m_tramp, SImode, chain_off), chain);
3591   emit_move_insn (adjust_address (m_tramp, SImode, func_off), func);
3592   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__xtensa_sync_caches"),
3593                      0, VOIDmode, 1, XEXP (m_tramp, 0), Pmode);
3594 }
3595
3596
3597 #include "gt-xtensa.h"