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