OSDN Git Service

* config/xtensa/xtensa.c (function_arg_advance): Check for args
[pf3gnuchains/gcc-fork.git] / gcc / config / xtensa / xtensa.c
1 /* Subroutines for insn-output.c for Tensilica's Xtensa architecture.
2    Copyright 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3    Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica.
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
10 version.
11
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING.  If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA.  */
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 "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-flags.h"
34 #include "insn-attr.h"
35 #include "insn-codes.h"
36 #include "recog.h"
37 #include "output.h"
38 #include "tree.h"
39 #include "expr.h"
40 #include "flags.h"
41 #include "reload.h"
42 #include "tm_p.h"
43 #include "function.h"
44 #include "toplev.h"
45 #include "optabs.h"
46 #include "libfuncs.h"
47 #include "ggc.h"
48 #include "target.h"
49 #include "target-def.h"
50 #include "langhooks.h"
51 #include "tree-gimple.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 /* Cached operands, and operator to compare for use in set/branch on
74    condition codes.  */
75 rtx branch_cmp[2];
76
77 /* what type of branch to use */
78 enum cmp_type branch_type;
79
80 /* Array giving truth value on whether or not a given hard register
81    can support a given mode.  */
82 char xtensa_hard_regno_mode_ok[(int) MAX_MACHINE_MODE][FIRST_PSEUDO_REGISTER];
83
84 /* Current frame size calculated by compute_frame_size.  */
85 unsigned xtensa_current_frame_size;
86
87 /* Tables of ld/st opcode names for block moves */
88 const char *xtensa_ld_opcodes[(int) MAX_MACHINE_MODE];
89 const char *xtensa_st_opcodes[(int) MAX_MACHINE_MODE];
90 #define LARGEST_MOVE_RATIO 15
91
92 /* Define the structure for the machine field in struct function.  */
93 struct machine_function GTY(())
94 {
95   int accesses_prev_frame;
96   bool need_a7_copy;
97   bool vararg_a7;
98   rtx set_frame_ptr_insn;
99 };
100
101 /* Vector, indexed by hard register number, which contains 1 for a
102    register that is allowable in a candidate for leaf function
103    treatment.  */
104
105 const char xtensa_leaf_regs[FIRST_PSEUDO_REGISTER] =
106 {
107   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
108   1, 1, 1,
109   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
110   1
111 };
112
113 /* Map hard register number to register class */
114 const enum reg_class xtensa_regno_to_class[FIRST_PSEUDO_REGISTER] =
115 {
116   RL_REGS,      SP_REG,         RL_REGS,        RL_REGS,
117   RL_REGS,      RL_REGS,        RL_REGS,        GR_REGS,
118   RL_REGS,      RL_REGS,        RL_REGS,        RL_REGS,
119   RL_REGS,      RL_REGS,        RL_REGS,        RL_REGS,
120   AR_REGS,      AR_REGS,        BR_REGS,
121   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
122   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
123   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
124   FP_REGS,      FP_REGS,        FP_REGS,        FP_REGS,
125   ACC_REG,
126 };
127
128 /* Map register constraint character to register class.  */
129 enum reg_class xtensa_char_to_class[256] =
130 {
131   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
132   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
133   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
134   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
135   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
136   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
137   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
138   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
139   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
140   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
141   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
142   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
143   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
144   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
145   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
146   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
147   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
148   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
149   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
150   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
151   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
152   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
153   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
154   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
155   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
156   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
157   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
158   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
159   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
160   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
161   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
162   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
163   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
164   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
165   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
166   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
167   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
168   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
169   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
170   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
171   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
172   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
173   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
174   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
175   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
176   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
177   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
178   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
179   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
180   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
181   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
182   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
183   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
184   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
185   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
186   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
187   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
188   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
189   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
190   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
191   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
192   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
193   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
194   NO_REGS,      NO_REGS,        NO_REGS,        NO_REGS,
195 };
196
197 static int b4const_or_zero (int);
198 static enum internal_test map_test_to_internal_test (enum rtx_code);
199 static rtx gen_int_relational (enum rtx_code, rtx, rtx, int *);
200 static rtx gen_float_relational (enum rtx_code, rtx, rtx);
201 static rtx gen_conditional_move (rtx);
202 static rtx fixup_subreg_mem (rtx);
203 static enum machine_mode xtensa_find_mode_for_size (unsigned);
204 static struct machine_function * xtensa_init_machine_status (void);
205 static bool xtensa_return_in_msb (tree);
206 static void printx (FILE *, signed int);
207 static void xtensa_function_epilogue (FILE *, HOST_WIDE_INT);
208 static rtx xtensa_builtin_saveregs (void);
209 static unsigned int xtensa_multibss_section_type_flags (tree, const char *,
210                                                         int) ATTRIBUTE_UNUSED;
211 static void xtensa_select_rtx_section (enum machine_mode, rtx,
212                                        unsigned HOST_WIDE_INT);
213 static bool xtensa_rtx_costs (rtx, int, int, int *);
214 static tree xtensa_build_builtin_va_list (void);
215 static bool xtensa_return_in_memory (tree, tree);
216 static tree xtensa_gimplify_va_arg_expr (tree, tree, tree *, tree *);
217
218 static const int reg_nonleaf_alloc_order[FIRST_PSEUDO_REGISTER] =
219   REG_ALLOC_ORDER;
220 \f
221
222 /* This macro generates the assembly code for function exit,
223    on machines that need it.  If FUNCTION_EPILOGUE is not defined
224    then individual return instructions are generated for each
225    return statement.  Args are same as for FUNCTION_PROLOGUE.  */
226
227 #undef TARGET_ASM_FUNCTION_EPILOGUE
228 #define TARGET_ASM_FUNCTION_EPILOGUE xtensa_function_epilogue
229
230 /* These hooks specify assembly directives for creating certain kinds
231    of integer object.  */
232
233 #undef TARGET_ASM_ALIGNED_SI_OP
234 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
235
236 #undef TARGET_ASM_SELECT_RTX_SECTION
237 #define TARGET_ASM_SELECT_RTX_SECTION  xtensa_select_rtx_section
238
239 #undef TARGET_RTX_COSTS
240 #define TARGET_RTX_COSTS xtensa_rtx_costs
241 #undef TARGET_ADDRESS_COST
242 #define TARGET_ADDRESS_COST hook_int_rtx_0
243
244 #undef TARGET_BUILD_BUILTIN_VA_LIST
245 #define TARGET_BUILD_BUILTIN_VA_LIST xtensa_build_builtin_va_list
246
247 #undef TARGET_PROMOTE_FUNCTION_ARGS
248 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
249 #undef TARGET_PROMOTE_FUNCTION_RETURN
250 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
251 #undef TARGET_PROMOTE_PROTOTYPES
252 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
253
254 #undef TARGET_RETURN_IN_MEMORY
255 #define TARGET_RETURN_IN_MEMORY xtensa_return_in_memory
256 #undef TARGET_SPLIT_COMPLEX_ARG
257 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_tree_true
258 #undef TARGET_MUST_PASS_IN_STACK
259 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
260
261 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
262 #define TARGET_EXPAND_BUILTIN_SAVEREGS xtensa_builtin_saveregs
263 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
264 #define TARGET_GIMPLIFY_VA_ARG_EXPR xtensa_gimplify_va_arg_expr
265
266 #undef TARGET_RETURN_IN_MSB
267 #define TARGET_RETURN_IN_MSB xtensa_return_in_msb
268
269 #undef TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE
270 #define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE hook_int_void_1
271
272 struct gcc_target targetm = TARGET_INITIALIZER;
273 \f
274
275 /*
276  * Functions to test Xtensa immediate operand validity.
277  */
278
279 int
280 xtensa_b4constu (int v)
281 {
282   switch (v)
283     {
284     case 32768:
285     case 65536:
286     case 2:
287     case 3:
288     case 4:
289     case 5:
290     case 6:
291     case 7:
292     case 8:
293     case 10:
294     case 12:
295     case 16:
296     case 32:
297     case 64:
298     case 128:
299     case 256:
300       return 1;
301     }
302   return 0;
303 }
304
305 int
306 xtensa_simm8x256 (int v)
307 {
308   return (v & 255) == 0 && (v >= -32768 && v <= 32512);
309 }
310
311 int
312 xtensa_ai4const (int v)
313 {
314   return (v == -1 || (v >= 1 && v <= 15));
315 }
316
317 int
318 xtensa_simm7 (int v)
319 {
320   return v >= -32 && v <= 95;
321 }
322
323 int
324 xtensa_b4const (int v)
325 {
326   switch (v)
327     {
328     case -1:
329     case 1:
330     case 2:
331     case 3:
332     case 4:
333     case 5:
334     case 6:
335     case 7:
336     case 8:
337     case 10:
338     case 12:
339     case 16:
340     case 32:
341     case 64:
342     case 128:
343     case 256:
344       return 1;
345     }
346   return 0;
347 }
348
349 int
350 xtensa_simm8 (int v)
351 {
352   return v >= -128 && v <= 127;
353 }
354
355 int
356 xtensa_tp7 (int v)
357 {
358   return (v >= 7 && v <= 22);
359 }
360
361 int
362 xtensa_lsi4x4 (int v)
363 {
364   return (v & 3) == 0 && (v >= 0 && v <= 60);
365 }
366
367 int
368 xtensa_simm12b (int v)
369 {
370   return v >= -2048 && v <= 2047;
371 }
372
373 int
374 xtensa_uimm8 (int v)
375 {
376   return v >= 0 && v <= 255;
377 }
378
379 int
380 xtensa_uimm8x2 (int v)
381 {
382   return (v & 1) == 0 && (v >= 0 && v <= 510);
383 }
384
385 int
386 xtensa_uimm8x4 (int v)
387 {
388   return (v & 3) == 0 && (v >= 0 && v <= 1020);
389 }
390
391
392 /* This is just like the standard true_regnum() function except that it
393    works even when reg_renumber is not initialized.  */
394
395 int
396 xt_true_regnum (rtx x)
397 {
398   if (GET_CODE (x) == REG)
399     {
400       if (reg_renumber
401           && REGNO (x) >= FIRST_PSEUDO_REGISTER
402           && reg_renumber[REGNO (x)] >= 0)
403         return reg_renumber[REGNO (x)];
404       return REGNO (x);
405     }
406   if (GET_CODE (x) == SUBREG)
407     {
408       int base = xt_true_regnum (SUBREG_REG (x));
409       if (base >= 0 && base < FIRST_PSEUDO_REGISTER)
410         return base + subreg_regno_offset (REGNO (SUBREG_REG (x)),
411                                            GET_MODE (SUBREG_REG (x)),
412                                            SUBREG_BYTE (x), GET_MODE (x));
413     }
414   return -1;
415 }
416
417
418 int
419 add_operand (rtx op, enum machine_mode mode)
420 {
421   if (GET_CODE (op) == CONST_INT)
422     return (xtensa_simm8 (INTVAL (op)) || xtensa_simm8x256 (INTVAL (op)));
423
424   return register_operand (op, mode);
425 }
426
427
428 int
429 arith_operand (rtx op, enum machine_mode mode)
430 {
431   if (GET_CODE (op) == CONST_INT)
432     return xtensa_simm8 (INTVAL (op));
433
434   return register_operand (op, mode);
435 }
436
437
438 int
439 nonimmed_operand (rtx op, enum machine_mode mode)
440 {
441   /* We cannot use the standard nonimmediate_operand() predicate because
442      it includes constant pool memory operands.  */
443
444   if (memory_operand (op, mode))
445     return !constantpool_address_p (XEXP (op, 0));
446
447   return register_operand (op, mode);
448 }
449
450
451 int
452 mem_operand (rtx op, enum machine_mode mode)
453 {
454   /* We cannot use the standard memory_operand() predicate because
455      it includes constant pool memory operands.  */
456
457   if (memory_operand (op, mode))
458     return !constantpool_address_p (XEXP (op, 0));
459
460   return FALSE;
461 }
462
463
464 int
465 xtensa_valid_move (enum machine_mode mode, rtx *operands)
466 {
467   /* Either the destination or source must be a register, and the
468      MAC16 accumulator doesn't count.  */
469
470   if (register_operand (operands[0], mode))
471     {
472       int dst_regnum = xt_true_regnum (operands[0]);
473
474       /* The stack pointer can only be assigned with a MOVSP opcode.  */
475       if (dst_regnum == STACK_POINTER_REGNUM)
476         return (mode == SImode
477                 && register_operand (operands[1], mode)
478                 && !ACC_REG_P (xt_true_regnum (operands[1])));
479
480       if (!ACC_REG_P (dst_regnum))
481         return true;
482     }
483   if (register_operand (operands[1], mode))
484     {
485       int src_regnum = xt_true_regnum (operands[1]);
486       if (!ACC_REG_P (src_regnum))
487         return true;
488     }
489   return FALSE;
490 }
491
492
493 int
494 mask_operand (rtx op, enum machine_mode mode)
495 {
496   if (GET_CODE (op) == CONST_INT)
497     return xtensa_mask_immediate (INTVAL (op));
498
499   return register_operand (op, mode);
500 }
501
502
503 int
504 extui_fldsz_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
505 {
506   return ((GET_CODE (op) == CONST_INT)
507           && xtensa_mask_immediate ((1 << INTVAL (op)) - 1));
508 }
509
510
511 int
512 sext_operand (rtx op, enum machine_mode mode)
513 {
514   if (TARGET_SEXT)
515     return nonimmed_operand (op, mode);
516   return mem_operand (op, mode);
517 }
518
519
520 int
521 sext_fldsz_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
522 {
523   return ((GET_CODE (op) == CONST_INT) && xtensa_tp7 (INTVAL (op) - 1));
524 }
525
526
527 int
528 lsbitnum_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
529 {
530   if (GET_CODE (op) == CONST_INT)
531     {
532       return (BITS_BIG_ENDIAN
533               ? (INTVAL (op) == BITS_PER_WORD-1)
534               : (INTVAL (op) == 0));
535     }
536   return FALSE;
537 }
538
539
540 static int
541 b4const_or_zero (int v)
542 {
543   if (v == 0)
544     return TRUE;
545   return xtensa_b4const (v);
546 }
547
548
549 int
550 branch_operand (rtx op, enum machine_mode mode)
551 {
552   if (GET_CODE (op) == CONST_INT)
553     return b4const_or_zero (INTVAL (op));
554
555   return register_operand (op, mode);
556 }
557
558
559 int
560 ubranch_operand (rtx op, enum machine_mode mode)
561 {
562   if (GET_CODE (op) == CONST_INT)
563     return xtensa_b4constu (INTVAL (op));
564
565   return register_operand (op, mode);
566 }
567
568
569 int
570 call_insn_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
571 {
572   if ((GET_CODE (op) == REG)
573       && (op != arg_pointer_rtx)
574       && ((REGNO (op) < FRAME_POINTER_REGNUM)
575           || (REGNO (op) > LAST_VIRTUAL_REGISTER)))
576     return TRUE;
577
578   if (CONSTANT_ADDRESS_P (op))
579     {
580       /* Direct calls only allowed to static functions with PIC.  */
581       if (flag_pic)
582         {
583           tree callee, callee_sec, caller_sec;
584
585           if (GET_CODE (op) != SYMBOL_REF
586               || !SYMBOL_REF_LOCAL_P (op) || SYMBOL_REF_EXTERNAL_P (op))
587             return FALSE;
588
589           /* Don't attempt a direct call if the callee is known to be in
590              a different section, since there's a good chance it will be
591              out of range.  */
592
593           if (flag_function_sections
594               || DECL_ONE_ONLY (current_function_decl))
595             return FALSE;
596           caller_sec = DECL_SECTION_NAME (current_function_decl);
597           callee = SYMBOL_REF_DECL (op);
598           if (callee)
599             {
600               if (DECL_ONE_ONLY (callee))
601                 return FALSE;
602               callee_sec = DECL_SECTION_NAME (callee);
603               if (((caller_sec == NULL_TREE) ^ (callee_sec == NULL_TREE))
604                   || (caller_sec != NULL_TREE
605                       && strcmp (TREE_STRING_POINTER (caller_sec),
606                                  TREE_STRING_POINTER (callee_sec)) != 0))
607                 return FALSE;
608             }
609           else if (caller_sec != NULL_TREE)
610             return FALSE;
611         }
612       return TRUE;
613     }
614
615   return FALSE;
616 }
617
618
619 int
620 move_operand (rtx op, enum machine_mode mode)
621 {
622   if (register_operand (op, mode)
623       || memory_operand (op, mode))
624     return TRUE;
625
626   switch (mode)
627     {
628     case DFmode:
629     case SFmode:
630       return TARGET_CONST16 && CONSTANT_P (op);
631
632     case DImode:
633     case SImode:
634       if (TARGET_CONST16)
635         return CONSTANT_P (op);
636       /* Fall through.  */
637
638     case HImode:
639     case QImode:
640       if (GET_CODE (op) == CONST_INT && xtensa_simm12b (INTVAL (op)))
641         return TRUE;
642       break;
643
644     default:
645       break;
646     }
647
648   return FALSE;
649 }
650
651
652 int
653 smalloffset_mem_p (rtx op)
654 {
655   if (GET_CODE (op) == MEM)
656     {
657       rtx addr = XEXP (op, 0);
658       if (GET_CODE (addr) == REG)
659         return REG_OK_FOR_BASE_P (addr);
660       if (GET_CODE (addr) == PLUS)
661         {
662           rtx offset = XEXP (addr, 0);
663           if (GET_CODE (offset) != CONST_INT)
664             offset = XEXP (addr, 1);
665           if (GET_CODE (offset) != CONST_INT)
666             return FALSE;
667           return xtensa_lsi4x4 (INTVAL (offset));
668         }
669     }
670   return FALSE;
671 }
672
673
674 int
675 constantpool_address_p (rtx addr)
676 {
677   rtx sym = addr;
678
679   if (GET_CODE (addr) == CONST)
680     {
681       rtx offset;
682
683       /* Only handle (PLUS (SYM, OFFSET)) form.  */
684       addr = XEXP (addr, 0);
685       if (GET_CODE (addr) != PLUS)
686         return FALSE;
687
688       /* Make sure the address is word aligned.  */
689       offset = XEXP (addr, 1);
690       if ((GET_CODE (offset) != CONST_INT)
691           || ((INTVAL (offset) & 3) != 0))
692         return FALSE;
693
694       sym = XEXP (addr, 0);
695     }
696
697   if ((GET_CODE (sym) == SYMBOL_REF)
698       && CONSTANT_POOL_ADDRESS_P (sym))
699     return TRUE;
700   return FALSE;
701 }
702
703
704 int
705 constantpool_mem_p (rtx op)
706 {
707   if (GET_CODE (op) == MEM)
708     return constantpool_address_p (XEXP (op, 0));
709   return FALSE;
710 }
711
712
713 /* Accept the floating point constant 1 in the appropriate mode.  */
714
715 int
716 const_float_1_operand (rtx op, enum machine_mode mode)
717 {
718   REAL_VALUE_TYPE d;
719   static REAL_VALUE_TYPE onedf;
720   static REAL_VALUE_TYPE onesf;
721   static int one_initialized;
722
723   if ((GET_CODE (op) != CONST_DOUBLE)
724       || (mode != GET_MODE (op))
725       || (mode != DFmode && mode != SFmode))
726     return FALSE;
727
728   REAL_VALUE_FROM_CONST_DOUBLE (d, op);
729
730   if (! one_initialized)
731     {
732       onedf = REAL_VALUE_ATOF ("1.0", DFmode);
733       onesf = REAL_VALUE_ATOF ("1.0", SFmode);
734       one_initialized = TRUE;
735     }
736
737   if (mode == DFmode)
738     return REAL_VALUES_EQUAL (d, onedf);
739   else
740     return REAL_VALUES_EQUAL (d, onesf);
741 }
742
743
744 int
745 fpmem_offset_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
746 {
747   if (GET_CODE (op) == CONST_INT)
748     return xtensa_mem_offset (INTVAL (op), SFmode);
749   return 0;
750 }
751
752
753 void
754 xtensa_extend_reg (rtx dst, rtx src)
755 {
756   rtx temp = gen_reg_rtx (SImode);
757   rtx shift = GEN_INT (BITS_PER_WORD - GET_MODE_BITSIZE (GET_MODE (src)));
758
759   /* Generate paradoxical subregs as needed so that the modes match.  */
760   src = simplify_gen_subreg (SImode, src, GET_MODE (src), 0);
761   dst = simplify_gen_subreg (SImode, dst, GET_MODE (dst), 0);
762
763   emit_insn (gen_ashlsi3 (temp, src, shift));
764   emit_insn (gen_ashrsi3 (dst, temp, shift));
765 }
766
767
768 int
769 branch_operator (rtx x, enum machine_mode mode)
770 {
771   if (GET_MODE (x) != mode)
772     return FALSE;
773
774   switch (GET_CODE (x))
775     {
776     case EQ:
777     case NE:
778     case LT:
779     case GE:
780       return TRUE;
781     default:
782       break;
783     }
784   return FALSE;
785 }
786
787
788 int
789 ubranch_operator (rtx x, enum machine_mode mode)
790 {
791   if (GET_MODE (x) != mode)
792     return FALSE;
793
794   switch (GET_CODE (x))
795     {
796     case LTU:
797     case GEU:
798       return TRUE;
799     default:
800       break;
801     }
802   return FALSE;
803 }
804
805
806 int
807 boolean_operator (rtx x, enum machine_mode mode)
808 {
809   if (GET_MODE (x) != mode)
810     return FALSE;
811
812   switch (GET_CODE (x))
813     {
814     case EQ:
815     case NE:
816       return TRUE;
817     default:
818       break;
819     }
820   return FALSE;
821 }
822
823
824 int
825 xtensa_mask_immediate (int v)
826 {
827 #define MAX_MASK_SIZE 16
828   int mask_size;
829
830   for (mask_size = 1; mask_size <= MAX_MASK_SIZE; mask_size++)
831     {
832       if ((v & 1) == 0)
833         return FALSE;
834       v = v >> 1;
835       if (v == 0)
836         return TRUE;
837     }
838
839   return FALSE;
840 }
841
842
843 int
844 xtensa_mem_offset (unsigned v, enum machine_mode mode)
845 {
846   switch (mode)
847     {
848     case BLKmode:
849       /* Handle the worst case for block moves.  See xtensa_expand_block_move
850          where we emit an optimized block move operation if the block can be
851          moved in < "move_ratio" pieces.  The worst case is when the block is
852          aligned but has a size of (3 mod 4) (does this happen?) so that the
853          last piece requires a byte load/store.  */
854       return (xtensa_uimm8 (v)
855               && xtensa_uimm8 (v + MOVE_MAX * LARGEST_MOVE_RATIO));
856
857     case QImode:
858       return xtensa_uimm8 (v);
859
860     case HImode:
861       return xtensa_uimm8x2 (v);
862
863     case DFmode:
864       return (xtensa_uimm8x4 (v) && xtensa_uimm8x4 (v + 4));
865
866     default:
867       break;
868     }
869
870   return xtensa_uimm8x4 (v);
871 }
872
873
874 /* Make normal rtx_code into something we can index from an array.  */
875
876 static enum internal_test
877 map_test_to_internal_test (enum rtx_code test_code)
878 {
879   enum internal_test test = ITEST_MAX;
880
881   switch (test_code)
882     {
883     default:                    break;
884     case EQ:  test = ITEST_EQ;  break;
885     case NE:  test = ITEST_NE;  break;
886     case GT:  test = ITEST_GT;  break;
887     case GE:  test = ITEST_GE;  break;
888     case LT:  test = ITEST_LT;  break;
889     case LE:  test = ITEST_LE;  break;
890     case GTU: test = ITEST_GTU; break;
891     case GEU: test = ITEST_GEU; break;
892     case LTU: test = ITEST_LTU; break;
893     case LEU: test = ITEST_LEU; break;
894     }
895
896   return test;
897 }
898
899
900 /* Generate the code to compare two integer values.  The return value is
901    the comparison expression.  */
902
903 static rtx
904 gen_int_relational (enum rtx_code test_code, /* relational test (EQ, etc) */
905                     rtx cmp0, /* first operand to compare */
906                     rtx cmp1, /* second operand to compare */
907                     int *p_invert /* whether branch needs to reverse test */)
908 {
909   struct cmp_info
910   {
911     enum rtx_code test_code;    /* test code to use in insn */
912     int (*const_range_p) (int); /* predicate function to check range */
913     int const_add;              /* constant to add (convert LE -> LT) */
914     int reverse_regs;           /* reverse registers in test */
915     int invert_const;           /* != 0 if invert value if cmp1 is constant */
916     int invert_reg;             /* != 0 if invert value if cmp1 is register */
917     int unsignedp;              /* != 0 for unsigned comparisons.  */
918   };
919
920   static struct cmp_info info[ (int)ITEST_MAX ] = {
921
922     { EQ,       b4const_or_zero,        0, 0, 0, 0, 0 },        /* EQ  */
923     { NE,       b4const_or_zero,        0, 0, 0, 0, 0 },        /* NE  */
924
925     { LT,       b4const_or_zero,        1, 1, 1, 0, 0 },        /* GT  */
926     { GE,       b4const_or_zero,        0, 0, 0, 0, 0 },        /* GE  */
927     { LT,       b4const_or_zero,        0, 0, 0, 0, 0 },        /* LT  */
928     { GE,       b4const_or_zero,        1, 1, 1, 0, 0 },        /* LE  */
929
930     { LTU,      xtensa_b4constu,        1, 1, 1, 0, 1 },        /* GTU */
931     { GEU,      xtensa_b4constu,        0, 0, 0, 0, 1 },        /* GEU */
932     { LTU,      xtensa_b4constu,        0, 0, 0, 0, 1 },        /* LTU */
933     { GEU,      xtensa_b4constu,        1, 1, 1, 0, 1 },        /* LEU */
934   };
935
936   enum internal_test test;
937   enum machine_mode mode;
938   struct cmp_info *p_info;
939
940   test = map_test_to_internal_test (test_code);
941   if (test == ITEST_MAX)
942     abort ();
943
944   p_info = &info[ (int)test ];
945
946   mode = GET_MODE (cmp0);
947   if (mode == VOIDmode)
948     mode = GET_MODE (cmp1);
949
950   /* Make sure we can handle any constants given to us.  */
951   if (GET_CODE (cmp1) == CONST_INT)
952     {
953       HOST_WIDE_INT value = INTVAL (cmp1);
954       unsigned HOST_WIDE_INT uvalue = (unsigned HOST_WIDE_INT)value;
955
956       /* if the immediate overflows or does not fit in the immediate field,
957          spill it to a register */
958
959       if ((p_info->unsignedp ?
960            (uvalue + p_info->const_add > uvalue) :
961            (value + p_info->const_add > value)) != (p_info->const_add > 0))
962         {
963           cmp1 = force_reg (mode, cmp1);
964         }
965       else if (!(p_info->const_range_p) (value + p_info->const_add))
966         {
967           cmp1 = force_reg (mode, cmp1);
968         }
969     }
970   else if ((GET_CODE (cmp1) != REG) && (GET_CODE (cmp1) != SUBREG))
971     {
972       cmp1 = force_reg (mode, cmp1);
973     }
974
975   /* See if we need to invert the result.  */
976   *p_invert = ((GET_CODE (cmp1) == CONST_INT)
977                ? p_info->invert_const
978                : p_info->invert_reg);
979
980   /* Comparison to constants, may involve adding 1 to change a LT into LE.
981      Comparison between two registers, may involve switching operands.  */
982   if (GET_CODE (cmp1) == CONST_INT)
983     {
984       if (p_info->const_add != 0)
985         cmp1 = GEN_INT (INTVAL (cmp1) + p_info->const_add);
986
987     }
988   else if (p_info->reverse_regs)
989     {
990       rtx temp = cmp0;
991       cmp0 = cmp1;
992       cmp1 = temp;
993     }
994
995   return gen_rtx_fmt_ee (p_info->test_code, VOIDmode, cmp0, cmp1);
996 }
997
998
999 /* Generate the code to compare two float values.  The return value is
1000    the comparison expression.  */
1001
1002 static rtx
1003 gen_float_relational (enum rtx_code test_code, /* relational test (EQ, etc) */
1004                       rtx cmp0, /* first operand to compare */
1005                       rtx cmp1 /* second operand to compare */)
1006 {
1007   rtx (*gen_fn) (rtx, rtx, rtx);
1008   rtx brtmp;
1009   int reverse_regs, invert;
1010
1011   switch (test_code)
1012     {
1013     case EQ: reverse_regs = 0; invert = 0; gen_fn = gen_seq_sf; break;
1014     case NE: reverse_regs = 0; invert = 1; gen_fn = gen_seq_sf; break;
1015     case LE: reverse_regs = 0; invert = 0; gen_fn = gen_sle_sf; break;
1016     case GT: reverse_regs = 1; invert = 0; gen_fn = gen_slt_sf; break;
1017     case LT: reverse_regs = 0; invert = 0; gen_fn = gen_slt_sf; break;
1018     case GE: reverse_regs = 1; invert = 0; gen_fn = gen_sle_sf; break;
1019     default:
1020       fatal_insn ("bad test", gen_rtx_fmt_ee (test_code, VOIDmode, cmp0, cmp1));
1021       reverse_regs = 0; invert = 0; gen_fn = 0; /* avoid compiler warnings */
1022     }
1023
1024   if (reverse_regs)
1025     {
1026       rtx temp = cmp0;
1027       cmp0 = cmp1;
1028       cmp1 = temp;
1029     }
1030
1031   brtmp = gen_rtx_REG (CCmode, FPCC_REGNUM);
1032   emit_insn (gen_fn (brtmp, cmp0, cmp1));
1033
1034   return gen_rtx_fmt_ee (invert ? EQ : NE, VOIDmode, brtmp, const0_rtx);
1035 }
1036
1037
1038 void
1039 xtensa_expand_conditional_branch (rtx *operands, enum rtx_code test_code)
1040 {
1041   enum cmp_type type = branch_type;
1042   rtx cmp0 = branch_cmp[0];
1043   rtx cmp1 = branch_cmp[1];
1044   rtx cmp;
1045   int invert;
1046   rtx label1, label2;
1047
1048   switch (type)
1049     {
1050     case CMP_DF:
1051     default:
1052       fatal_insn ("bad test", gen_rtx_fmt_ee (test_code, VOIDmode, cmp0, cmp1));
1053
1054     case CMP_SI:
1055       invert = FALSE;
1056       cmp = gen_int_relational (test_code, cmp0, cmp1, &invert);
1057       break;
1058
1059     case CMP_SF:
1060       if (!TARGET_HARD_FLOAT)
1061         fatal_insn ("bad test", gen_rtx_fmt_ee (test_code, VOIDmode, cmp0, cmp1));
1062       invert = FALSE;
1063       cmp = gen_float_relational (test_code, cmp0, cmp1);
1064       break;
1065     }
1066
1067   /* Generate the branch.  */
1068
1069   label1 = gen_rtx_LABEL_REF (VOIDmode, operands[0]);
1070   label2 = pc_rtx;
1071
1072   if (invert)
1073     {
1074       label2 = label1;
1075       label1 = pc_rtx;
1076     }
1077
1078   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
1079                                gen_rtx_IF_THEN_ELSE (VOIDmode, cmp,
1080                                                      label1,
1081                                                      label2)));
1082 }
1083
1084
1085 static rtx
1086 gen_conditional_move (rtx cmp)
1087 {
1088   enum rtx_code code = GET_CODE (cmp);
1089   rtx op0 = branch_cmp[0];
1090   rtx op1 = branch_cmp[1];
1091
1092   if (branch_type == CMP_SI)
1093     {
1094       /* Jump optimization calls get_condition() which canonicalizes
1095          comparisons like (GE x <const>) to (GT x <const-1>).
1096          Transform those comparisons back to GE, since that is the
1097          comparison supported in Xtensa.  We shouldn't have to
1098          transform <LE x const> comparisons, because neither
1099          xtensa_expand_conditional_branch() nor get_condition() will
1100          produce them.  */
1101
1102       if ((code == GT) && (op1 == constm1_rtx))
1103         {
1104           code = GE;
1105           op1 = const0_rtx;
1106         }
1107       cmp = gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
1108
1109       if (boolean_operator (cmp, VOIDmode))
1110         {
1111           /* Swap the operands to make const0 second.  */
1112           if (op0 == const0_rtx)
1113             {
1114               op0 = op1;
1115               op1 = const0_rtx;
1116             }
1117
1118           /* If not comparing against zero, emit a comparison (subtract).  */
1119           if (op1 != const0_rtx)
1120             {
1121               op0 = expand_binop (SImode, sub_optab, op0, op1,
1122                                   0, 0, OPTAB_LIB_WIDEN);
1123               op1 = const0_rtx;
1124             }
1125         }
1126       else if (branch_operator (cmp, VOIDmode))
1127         {
1128           /* Swap the operands to make const0 second.  */
1129           if (op0 == const0_rtx)
1130             {
1131               op0 = op1;
1132               op1 = const0_rtx;
1133
1134               switch (code)
1135                 {
1136                 case LT: code = GE; break;
1137                 case GE: code = LT; break;
1138                 default: abort ();
1139                 }
1140             }
1141
1142           if (op1 != const0_rtx)
1143             return 0;
1144         }
1145       else
1146         return 0;
1147
1148       return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
1149     }
1150
1151   if (TARGET_HARD_FLOAT && (branch_type == CMP_SF))
1152     return gen_float_relational (code, op0, op1);
1153
1154   return 0;
1155 }
1156
1157
1158 int
1159 xtensa_expand_conditional_move (rtx *operands, int isflt)
1160 {
1161   rtx cmp;
1162   rtx (*gen_fn) (rtx, rtx, rtx, rtx, rtx);
1163
1164   if (!(cmp = gen_conditional_move (operands[1])))
1165     return 0;
1166
1167   if (isflt)
1168     gen_fn = (branch_type == CMP_SI
1169               ? gen_movsfcc_internal0
1170               : gen_movsfcc_internal1);
1171   else
1172     gen_fn = (branch_type == CMP_SI
1173               ? gen_movsicc_internal0
1174               : gen_movsicc_internal1);
1175
1176   emit_insn (gen_fn (operands[0], XEXP (cmp, 0),
1177                      operands[2], operands[3], cmp));
1178   return 1;
1179 }
1180
1181
1182 int
1183 xtensa_expand_scc (rtx *operands)
1184 {
1185   rtx dest = operands[0];
1186   rtx cmp = operands[1];
1187   rtx one_tmp, zero_tmp;
1188   rtx (*gen_fn) (rtx, rtx, rtx, rtx, rtx);
1189
1190   if (!(cmp = gen_conditional_move (cmp)))
1191     return 0;
1192
1193   one_tmp = gen_reg_rtx (SImode);
1194   zero_tmp = gen_reg_rtx (SImode);
1195   emit_insn (gen_movsi (one_tmp, const_true_rtx));
1196   emit_insn (gen_movsi (zero_tmp, const0_rtx));
1197
1198   gen_fn = (branch_type == CMP_SI
1199             ? gen_movsicc_internal0
1200             : gen_movsicc_internal1);
1201   emit_insn (gen_fn (dest, XEXP (cmp, 0), one_tmp, zero_tmp, cmp));
1202   return 1;
1203 }
1204
1205
1206 /* Split OP[1] into OP[2,3] and likewise for OP[0] into OP[0,1].  MODE is
1207    for the output, i.e., the input operands are twice as big as MODE.  */
1208
1209 void
1210 xtensa_split_operand_pair (rtx operands[4], enum machine_mode mode)
1211 {
1212   switch (GET_CODE (operands[1]))
1213     {
1214     case REG:
1215       operands[3] = gen_rtx_REG (mode, REGNO (operands[1]) + 1);
1216       operands[2] = gen_rtx_REG (mode, REGNO (operands[1]));
1217       break;
1218
1219     case MEM:
1220       operands[3] = adjust_address (operands[1], mode, GET_MODE_SIZE (mode));
1221       operands[2] = adjust_address (operands[1], mode, 0);
1222       break;
1223
1224     case CONST_INT:
1225     case CONST_DOUBLE:
1226       split_double (operands[1], &operands[2], &operands[3]);
1227       break;
1228
1229     default:
1230       abort ();
1231     }
1232
1233   switch (GET_CODE (operands[0]))
1234     {
1235     case REG:
1236       operands[1] = gen_rtx_REG (mode, REGNO (operands[0]) + 1);
1237       operands[0] = gen_rtx_REG (mode, REGNO (operands[0]));
1238       break;
1239
1240     case MEM:
1241       operands[1] = adjust_address (operands[0], mode, GET_MODE_SIZE (mode));
1242       operands[0] = adjust_address (operands[0], mode, 0);
1243       break;
1244
1245     default:
1246       abort ();
1247     }
1248 }
1249
1250
1251 /* Emit insns to move operands[1] into operands[0].
1252    Return 1 if we have written out everything that needs to be done to
1253    do the move.  Otherwise, return 0 and the caller will emit the move
1254    normally.  */
1255
1256 int
1257 xtensa_emit_move_sequence (rtx *operands, enum machine_mode mode)
1258 {
1259   if (CONSTANT_P (operands[1])
1260       && (GET_CODE (operands[1]) != CONST_INT
1261           || !xtensa_simm12b (INTVAL (operands[1]))))
1262     {
1263       if (!TARGET_CONST16)
1264         operands[1] = force_const_mem (SImode, operands[1]);
1265
1266       /* PC-relative loads are always SImode, and CONST16 is only
1267          supported in the movsi pattern, so add a SUBREG for any other
1268          (smaller) mode.  */
1269
1270       if (mode != SImode)
1271         {
1272           if (register_operand (operands[0], mode))
1273             {
1274               operands[0] = simplify_gen_subreg (SImode, operands[0], mode, 0);
1275               emit_move_insn (operands[0], operands[1]);
1276               return 1;
1277             }
1278           else
1279             {
1280               operands[1] = force_reg (SImode, operands[1]);
1281               operands[1] = gen_lowpart_SUBREG (mode, operands[1]);
1282             }
1283         }
1284     }
1285
1286   if (!(reload_in_progress | reload_completed)
1287       && !xtensa_valid_move (mode, operands))
1288     operands[1] = force_reg (mode, operands[1]);
1289
1290   operands[1] = xtensa_copy_incoming_a7 (operands[1]);
1291
1292   /* During reload we don't want to emit (subreg:X (mem:Y)) since that
1293      instruction won't be recognized after reload, so we remove the
1294      subreg and adjust mem accordingly.  */
1295   if (reload_in_progress)
1296     {
1297       operands[0] = fixup_subreg_mem (operands[0]);
1298       operands[1] = fixup_subreg_mem (operands[1]);
1299     }
1300   return 0;
1301 }
1302
1303
1304 static rtx
1305 fixup_subreg_mem (rtx x)
1306 {
1307   if (GET_CODE (x) == SUBREG
1308       && GET_CODE (SUBREG_REG (x)) == REG
1309       && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER)
1310     {
1311       rtx temp =
1312         gen_rtx_SUBREG (GET_MODE (x),
1313                         reg_equiv_mem [REGNO (SUBREG_REG (x))],
1314                         SUBREG_BYTE (x));
1315       x = alter_subreg (&temp);
1316     }
1317   return x;
1318 }
1319
1320
1321 /* Check if an incoming argument in a7 is expected to be used soon and
1322    if OPND is a register or register pair that includes a7.  If so,
1323    create a new pseudo and copy a7 into that pseudo at the very
1324    beginning of the function, followed by the special "set_frame_ptr"
1325    unspec_volatile insn.  The return value is either the original
1326    operand, if it is not a7, or the new pseudo containing a copy of
1327    the incoming argument.  This is necessary because the register
1328    allocator will ignore conflicts with a7 and may either assign some
1329    other pseudo to a7 or use a7 as the hard_frame_pointer, clobbering
1330    the incoming argument in a7.  By copying the argument out of a7 as
1331    the very first thing, and then immediately following that with an
1332    unspec_volatile to keep the scheduler away, we should avoid any
1333    problems.  Putting the set_frame_ptr insn at the beginning, with
1334    only the a7 copy before it, also makes it easier for the prologue
1335    expander to initialize the frame pointer after the a7 copy and to
1336    fix up the a7 copy to use the stack pointer instead of the frame
1337    pointer.  */
1338
1339 rtx
1340 xtensa_copy_incoming_a7 (rtx opnd)
1341 {
1342   rtx entry_insns = 0;
1343   rtx reg, tmp;
1344   enum machine_mode mode;
1345
1346   if (!cfun->machine->need_a7_copy)
1347     return opnd;
1348
1349   /* This function should never be called again once a7 has been copied.  */
1350   if (cfun->machine->set_frame_ptr_insn)
1351     abort ();
1352
1353   mode = GET_MODE (opnd);
1354
1355   /* The operand using a7 may come in a later instruction, so just return
1356      the original operand if it doesn't use a7.  */
1357   reg = opnd;
1358   if (GET_CODE (reg) == SUBREG)
1359     {
1360       if (SUBREG_BYTE (reg) != 0)
1361         abort ();
1362       reg = SUBREG_REG (reg);
1363     }
1364   if (GET_CODE (reg) != REG
1365       || REGNO (reg) > A7_REG
1366       || REGNO (reg) + HARD_REGNO_NREGS (A7_REG, mode) <= A7_REG)
1367     return opnd;
1368
1369   /* 1-word args will always be in a7; 2-word args in a6/a7.  */
1370   if (REGNO (reg) + HARD_REGNO_NREGS (A7_REG, mode) - 1 != A7_REG)
1371     abort ();
1372
1373   cfun->machine->need_a7_copy = false;
1374
1375   /* Copy a7 to a new pseudo at the function entry.  Use gen_raw_REG to
1376      create the REG for a7 so that hard_frame_pointer_rtx is not used.  */
1377
1378   push_to_sequence (entry_insns);
1379   tmp = gen_reg_rtx (mode);
1380
1381   switch (mode)
1382     {
1383     case DFmode:
1384     case DImode:
1385       emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 0),
1386                                      gen_rtx_REG (SImode, A7_REG - 1)));
1387       emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode, tmp, 4),
1388                                      gen_raw_REG (SImode, A7_REG)));
1389       break;
1390     case SFmode:
1391       emit_insn (gen_movsf_internal (tmp, gen_raw_REG (mode, A7_REG)));
1392       break;
1393     case SImode:
1394       emit_insn (gen_movsi_internal (tmp, gen_raw_REG (mode, A7_REG)));
1395       break;
1396     case HImode:
1397       emit_insn (gen_movhi_internal (tmp, gen_raw_REG (mode, A7_REG)));
1398       break;
1399     case QImode:
1400       emit_insn (gen_movqi_internal (tmp, gen_raw_REG (mode, A7_REG)));
1401       break;
1402     default:
1403       abort ();
1404     }
1405
1406   cfun->machine->set_frame_ptr_insn = emit_insn (gen_set_frame_ptr ());
1407   entry_insns = get_insns ();
1408   end_sequence ();
1409
1410   if (cfun->machine->vararg_a7)
1411     {
1412       /* This is called from within builtin_savereg, so we're already
1413          inside a start_sequence that will be placed at the start of
1414          the function.  */
1415       emit_insn (entry_insns);
1416     }
1417   else
1418     {
1419       /* Put entry_insns after the NOTE that starts the function.  If
1420          this is inside a start_sequence, make the outer-level insn
1421          chain current, so the code is placed at the start of the
1422          function.  */
1423       push_topmost_sequence ();
1424       emit_insn_after (entry_insns, get_insns ());
1425       pop_topmost_sequence ();
1426     }
1427
1428   return tmp;
1429 }
1430
1431
1432 /* Try to expand a block move operation to an RTL block move instruction.
1433    If not optimizing or if the block size is not a constant or if the
1434    block is small, the expansion fails and GCC falls back to calling
1435    memcpy().
1436
1437    operands[0] is the destination
1438    operands[1] is the source
1439    operands[2] is the length
1440    operands[3] is the alignment */
1441
1442 int
1443 xtensa_expand_block_move (rtx *operands)
1444 {
1445   rtx dest = operands[0];
1446   rtx src = operands[1];
1447   int bytes = INTVAL (operands[2]);
1448   int align = XINT (operands[3], 0);
1449   int num_pieces, move_ratio;
1450
1451   /* If this is not a fixed size move, just call memcpy.  */
1452   if (!optimize || (GET_CODE (operands[2]) != CONST_INT))
1453     return 0;
1454
1455   /* Anything to move?  */
1456   if (bytes <= 0)
1457     return 1;
1458
1459   if (align > MOVE_MAX)
1460     align = MOVE_MAX;
1461
1462   /* Decide whether to expand inline based on the optimization level.  */
1463   move_ratio = 4;
1464   if (optimize > 2)
1465     move_ratio = LARGEST_MOVE_RATIO;
1466   num_pieces = (bytes / align) + (bytes % align); /* Close enough anyway.  */
1467   if (num_pieces >= move_ratio)
1468     return 0;
1469
1470   /* Make sure the memory addresses are valid.  */
1471   operands[0] = validize_mem (dest);
1472   operands[1] = validize_mem (src);
1473
1474   emit_insn (gen_movmemsi_internal (operands[0], operands[1],
1475                                     operands[2], operands[3]));
1476   return 1;
1477 }
1478
1479
1480 /* Emit a sequence of instructions to implement a block move, trying
1481    to hide load delay slots as much as possible.  Load N values into
1482    temporary registers, store those N values, and repeat until the
1483    complete block has been moved.  N=delay_slots+1.  */
1484
1485 struct meminsnbuf
1486 {
1487   char template[30];
1488   rtx operands[2];
1489 };
1490
1491 void
1492 xtensa_emit_block_move (rtx *operands, rtx *tmpregs, int delay_slots)
1493 {
1494   rtx dest = operands[0];
1495   rtx src = operands[1];
1496   int bytes = INTVAL (operands[2]);
1497   int align = XINT (operands[3], 0);
1498   rtx from_addr = XEXP (src, 0);
1499   rtx to_addr = XEXP (dest, 0);
1500   int from_struct = MEM_IN_STRUCT_P (src);
1501   int to_struct = MEM_IN_STRUCT_P (dest);
1502   int offset = 0;
1503   int chunk_size, item_size;
1504   struct meminsnbuf *ldinsns, *stinsns;
1505   const char *ldname, *stname;
1506   enum machine_mode mode;
1507
1508   if (align > MOVE_MAX)
1509     align = MOVE_MAX;
1510   item_size = align;
1511   chunk_size = delay_slots + 1;
1512
1513   ldinsns = (struct meminsnbuf *)
1514     alloca (chunk_size * sizeof (struct meminsnbuf));
1515   stinsns = (struct meminsnbuf *)
1516     alloca (chunk_size * sizeof (struct meminsnbuf));
1517
1518   mode = xtensa_find_mode_for_size (item_size);
1519   item_size = GET_MODE_SIZE (mode);
1520   ldname = xtensa_ld_opcodes[(int) mode];
1521   stname = xtensa_st_opcodes[(int) mode];
1522
1523   while (bytes > 0)
1524     {
1525       int n;
1526
1527       for (n = 0; n < chunk_size; n++)
1528         {
1529           rtx addr, mem;
1530
1531           if (bytes == 0)
1532             {
1533               chunk_size = n;
1534               break;
1535             }
1536
1537           if (bytes < item_size)
1538             {
1539               /* Find a smaller item_size which we can load & store.  */
1540               item_size = bytes;
1541               mode = xtensa_find_mode_for_size (item_size);
1542               item_size = GET_MODE_SIZE (mode);
1543               ldname = xtensa_ld_opcodes[(int) mode];
1544               stname = xtensa_st_opcodes[(int) mode];
1545             }
1546
1547           /* Record the load instruction opcode and operands.  */
1548           addr = plus_constant (from_addr, offset);
1549           mem = gen_rtx_MEM (mode, addr);
1550           if (! memory_address_p (mode, addr))
1551             abort ();
1552           MEM_IN_STRUCT_P (mem) = from_struct;
1553           ldinsns[n].operands[0] = tmpregs[n];
1554           ldinsns[n].operands[1] = mem;
1555           sprintf (ldinsns[n].template, "%s\t%%0, %%1", ldname);
1556
1557           /* Record the store instruction opcode and operands.  */
1558           addr = plus_constant (to_addr, offset);
1559           mem = gen_rtx_MEM (mode, addr);
1560           if (! memory_address_p (mode, addr))
1561             abort ();
1562           MEM_IN_STRUCT_P (mem) = to_struct;
1563           stinsns[n].operands[0] = tmpregs[n];
1564           stinsns[n].operands[1] = mem;
1565           sprintf (stinsns[n].template, "%s\t%%0, %%1", stname);
1566
1567           offset += item_size;
1568           bytes -= item_size;
1569         }
1570
1571       /* Now output the loads followed by the stores.  */
1572       for (n = 0; n < chunk_size; n++)
1573         output_asm_insn (ldinsns[n].template, ldinsns[n].operands);
1574       for (n = 0; n < chunk_size; n++)
1575         output_asm_insn (stinsns[n].template, stinsns[n].operands);
1576     }
1577 }
1578
1579
1580 static enum machine_mode
1581 xtensa_find_mode_for_size (unsigned item_size)
1582 {
1583   enum machine_mode mode, tmode;
1584
1585   while (1)
1586     {
1587       mode = VOIDmode;
1588
1589       /* Find mode closest to but not bigger than item_size.  */
1590       for (tmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1591            tmode != VOIDmode; tmode = GET_MODE_WIDER_MODE (tmode))
1592         if (GET_MODE_SIZE (tmode) <= item_size)
1593           mode = tmode;
1594       if (mode == VOIDmode)
1595         abort ();
1596
1597       item_size = GET_MODE_SIZE (mode);
1598
1599       if (xtensa_ld_opcodes[(int) mode]
1600           && xtensa_st_opcodes[(int) mode])
1601         break;
1602
1603       /* Cannot load & store this mode; try something smaller.  */
1604       item_size -= 1;
1605     }
1606
1607   return mode;
1608 }
1609
1610
1611 void
1612 xtensa_expand_nonlocal_goto (rtx *operands)
1613 {
1614   rtx goto_handler = operands[1];
1615   rtx containing_fp = operands[3];
1616
1617   /* Generate a call to "__xtensa_nonlocal_goto" (in libgcc); the code
1618      is too big to generate in-line.  */
1619
1620   if (GET_CODE (containing_fp) != REG)
1621     containing_fp = force_reg (Pmode, containing_fp);
1622
1623   goto_handler = replace_rtx (copy_rtx (goto_handler),
1624                               virtual_stack_vars_rtx,
1625                               containing_fp);
1626
1627   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__xtensa_nonlocal_goto"),
1628                      0, VOIDmode, 2,
1629                      containing_fp, Pmode,
1630                      goto_handler, Pmode);
1631 }
1632
1633
1634 static struct machine_function *
1635 xtensa_init_machine_status (void)
1636 {
1637   return ggc_alloc_cleared (sizeof (struct machine_function));
1638 }
1639
1640
1641 void
1642 xtensa_setup_frame_addresses (void)
1643 {
1644   /* Set flag to cause FRAME_POINTER_REQUIRED to be set.  */
1645   cfun->machine->accesses_prev_frame = 1;
1646
1647   emit_library_call
1648     (gen_rtx_SYMBOL_REF (Pmode, "__xtensa_libgcc_window_spill"),
1649      0, VOIDmode, 0);
1650 }
1651
1652
1653 /* Emit the assembly for the end of a zero-cost loop.  Normally we just emit
1654    a comment showing where the end of the loop is.  However, if there is a
1655    label or a branch at the end of the loop then we need to place a nop
1656    there.  If the loop ends with a label we need the nop so that branches
1657    targeting that label will target the nop (and thus remain in the loop),
1658    instead of targeting the instruction after the loop (and thus exiting
1659    the loop).  If the loop ends with a branch, we need the nop in case the
1660    branch is targeting a location inside the loop.  When the branch
1661    executes it will cause the loop count to be decremented even if it is
1662    taken (because it is the last instruction in the loop), so we need to
1663    nop after the branch to prevent the loop count from being decremented
1664    when the branch is taken.  */
1665
1666 void
1667 xtensa_emit_loop_end (rtx insn, rtx *operands)
1668 {
1669   char done = 0;
1670
1671   for (insn = PREV_INSN (insn); insn && !done; insn = PREV_INSN (insn))
1672     {
1673       switch (GET_CODE (insn))
1674         {
1675         case NOTE:
1676         case BARRIER:
1677           break;
1678
1679         case CODE_LABEL:
1680           output_asm_insn (TARGET_DENSITY ? "nop.n" : "nop", operands);
1681           done = 1;
1682           break;
1683
1684         default:
1685           {
1686             rtx body = PATTERN (insn);
1687
1688             if (GET_CODE (body) == JUMP_INSN)
1689               {
1690                 output_asm_insn (TARGET_DENSITY ? "nop.n" : "nop", operands);
1691                 done = 1;
1692               }
1693             else if ((GET_CODE (body) != USE)
1694                      && (GET_CODE (body) != CLOBBER))
1695               done = 1;
1696           }
1697           break;
1698         }
1699     }
1700
1701   output_asm_insn ("# loop end for %0", operands);
1702 }
1703
1704
1705 char *
1706 xtensa_emit_call (int callop, rtx *operands)
1707 {
1708   static char result[64];
1709   rtx tgt = operands[callop];
1710
1711   if (GET_CODE (tgt) == CONST_INT)
1712     sprintf (result, "call8\t0x%lx", INTVAL (tgt));
1713   else if (register_operand (tgt, VOIDmode))
1714     sprintf (result, "callx8\t%%%d", callop);
1715   else
1716     sprintf (result, "call8\t%%%d", callop);
1717
1718   return result;
1719 }
1720
1721
1722 /* Return the debugger register number to use for 'regno'.  */
1723
1724 int
1725 xtensa_dbx_register_number (int regno)
1726 {
1727   int first = -1;
1728
1729   if (GP_REG_P (regno))
1730     {
1731       regno -= GP_REG_FIRST;
1732       first = 0;
1733     }
1734   else if (BR_REG_P (regno))
1735     {
1736       regno -= BR_REG_FIRST;
1737       first = 16;
1738     }
1739   else if (FP_REG_P (regno))
1740     {
1741       regno -= FP_REG_FIRST;
1742       first = 48;
1743     }
1744   else if (ACC_REG_P (regno))
1745     {
1746       first = 0x200;    /* Start of Xtensa special registers.  */
1747       regno = 16;       /* ACCLO is special register 16.  */
1748     }
1749
1750   /* When optimizing, we sometimes get asked about pseudo-registers
1751      that don't represent hard registers.  Return 0 for these.  */
1752   if (first == -1)
1753     return 0;
1754
1755   return first + regno;
1756 }
1757
1758
1759 /* Argument support functions.  */
1760
1761 /* Initialize CUMULATIVE_ARGS for a function.  */
1762
1763 void
1764 init_cumulative_args (CUMULATIVE_ARGS *cum, int incoming)
1765 {
1766   cum->arg_words = 0;
1767   cum->incoming = incoming;
1768 }
1769
1770
1771 /* Advance the argument to the next argument position.  */
1772
1773 void
1774 function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type)
1775 {
1776   int words, max;
1777   int *arg_words;
1778
1779   arg_words = &cum->arg_words;
1780   max = MAX_ARGS_IN_REGISTERS;
1781
1782   words = (((mode != BLKmode)
1783             ? (int) GET_MODE_SIZE (mode)
1784             : int_size_in_bytes (type)) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1785
1786   if (*arg_words < max
1787       && (targetm.calls.must_pass_in_stack (mode, type)
1788           || *arg_words + words > max))
1789     *arg_words = max;
1790
1791   *arg_words += words;
1792 }
1793
1794
1795 /* Return an RTL expression containing the register for the given mode,
1796    or 0 if the argument is to be passed on the stack.  INCOMING_P is nonzero
1797    if this is an incoming argument to the current function.  */
1798
1799 rtx
1800 function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
1801               int incoming_p)
1802 {
1803   int regbase, words, max;
1804   int *arg_words;
1805   int regno;
1806
1807   arg_words = &cum->arg_words;
1808   regbase = (incoming_p ? GP_ARG_FIRST : GP_OUTGOING_ARG_FIRST);
1809   max = MAX_ARGS_IN_REGISTERS;
1810
1811   words = (((mode != BLKmode)
1812             ? (int) GET_MODE_SIZE (mode)
1813             : int_size_in_bytes (type)) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1814
1815   if (type && (TYPE_ALIGN (type) > BITS_PER_WORD))
1816     {
1817       int align = TYPE_ALIGN (type) / BITS_PER_WORD;
1818       *arg_words = (*arg_words + align - 1) & -align;
1819     }
1820
1821   if (*arg_words + words > max)
1822     return (rtx)0;
1823
1824   regno = regbase + *arg_words;
1825
1826   if (cum->incoming && regno <= A7_REG && regno + words > A7_REG)
1827     cfun->machine->need_a7_copy = true;
1828
1829   return gen_rtx_REG (mode, regno);
1830 }
1831
1832
1833 static bool
1834 xtensa_return_in_msb (tree valtype)
1835 {
1836   return (TARGET_BIG_ENDIAN
1837           && AGGREGATE_TYPE_P (valtype)
1838           && int_size_in_bytes (valtype) >= UNITS_PER_WORD);
1839 }
1840
1841
1842 void
1843 override_options (void)
1844 {
1845   int regno;
1846   enum machine_mode mode;
1847
1848   if (!TARGET_BOOLEANS && TARGET_HARD_FLOAT)
1849     error ("boolean registers required for the floating-point option");
1850
1851   /* Set up the tables of ld/st opcode names for block moves.  */
1852   xtensa_ld_opcodes[(int) SImode] = "l32i";
1853   xtensa_ld_opcodes[(int) HImode] = "l16ui";
1854   xtensa_ld_opcodes[(int) QImode] = "l8ui";
1855   xtensa_st_opcodes[(int) SImode] = "s32i";
1856   xtensa_st_opcodes[(int) HImode] = "s16i";
1857   xtensa_st_opcodes[(int) QImode] = "s8i";
1858
1859   xtensa_char_to_class['q'] = SP_REG;
1860   xtensa_char_to_class['a'] = GR_REGS;
1861   xtensa_char_to_class['b'] = ((TARGET_BOOLEANS) ? BR_REGS : NO_REGS);
1862   xtensa_char_to_class['f'] = ((TARGET_HARD_FLOAT) ? FP_REGS : NO_REGS);
1863   xtensa_char_to_class['A'] = ((TARGET_MAC16) ? ACC_REG : NO_REGS);
1864   xtensa_char_to_class['B'] = ((TARGET_SEXT) ? GR_REGS : NO_REGS);
1865   xtensa_char_to_class['C'] = ((TARGET_MUL16) ? GR_REGS: NO_REGS);
1866   xtensa_char_to_class['D'] = ((TARGET_DENSITY) ? GR_REGS: NO_REGS);
1867   xtensa_char_to_class['d'] = ((TARGET_DENSITY) ? AR_REGS: NO_REGS);
1868   xtensa_char_to_class['W'] = ((TARGET_CONST16) ? GR_REGS: NO_REGS);
1869
1870   /* Set up array giving whether a given register can hold a given mode.  */
1871   for (mode = VOIDmode;
1872        mode != MAX_MACHINE_MODE;
1873        mode = (enum machine_mode) ((int) mode + 1))
1874     {
1875       int size = GET_MODE_SIZE (mode);
1876       enum mode_class class = GET_MODE_CLASS (mode);
1877
1878       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1879         {
1880           int temp;
1881
1882           if (ACC_REG_P (regno))
1883             temp = (TARGET_MAC16
1884                     && (class == MODE_INT) && (size <= UNITS_PER_WORD));
1885           else if (GP_REG_P (regno))
1886             temp = ((regno & 1) == 0 || (size <= UNITS_PER_WORD));
1887           else if (FP_REG_P (regno))
1888             temp = (TARGET_HARD_FLOAT && (mode == SFmode));
1889           else if (BR_REG_P (regno))
1890             temp = (TARGET_BOOLEANS && (mode == CCmode));
1891           else
1892             temp = FALSE;
1893
1894           xtensa_hard_regno_mode_ok[(int) mode][regno] = temp;
1895         }
1896     }
1897
1898   init_machine_status = xtensa_init_machine_status;
1899
1900   /* Check PIC settings.  PIC is only supported when using L32R
1901      instructions, and some targets need to always use PIC.  */
1902   if (flag_pic && TARGET_CONST16)
1903     error ("-f%s is not supported with CONST16 instructions",
1904            (flag_pic > 1 ? "PIC" : "pic"));
1905   else if (XTENSA_ALWAYS_PIC)
1906     {
1907       if (TARGET_CONST16)
1908         error ("PIC is required but not supported with CONST16 instructions");
1909       flag_pic = 1;
1910     }
1911   /* There's no need for -fPIC (as opposed to -fpic) on Xtensa.  */
1912   if (flag_pic > 1)
1913     flag_pic = 1;
1914 }
1915
1916
1917 /* A C compound statement to output to stdio stream STREAM the
1918    assembler syntax for an instruction operand X.  X is an RTL
1919    expression.
1920
1921    CODE is a value that can be used to specify one of several ways
1922    of printing the operand.  It is used when identical operands
1923    must be printed differently depending on the context.  CODE
1924    comes from the '%' specification that was used to request
1925    printing of the operand.  If the specification was just '%DIGIT'
1926    then CODE is 0; if the specification was '%LTR DIGIT' then CODE
1927    is the ASCII code for LTR.
1928
1929    If X is a register, this macro should print the register's name.
1930    The names can be found in an array 'reg_names' whose type is
1931    'char *[]'.  'reg_names' is initialized from 'REGISTER_NAMES'.
1932
1933    When the machine description has a specification '%PUNCT' (a '%'
1934    followed by a punctuation character), this macro is called with
1935    a null pointer for X and the punctuation character for CODE.
1936
1937    'a', 'c', 'l', and 'n' are reserved.
1938
1939    The Xtensa specific codes are:
1940
1941    'd'  CONST_INT, print as signed decimal
1942    'x'  CONST_INT, print as signed hexadecimal
1943    'K'  CONST_INT, print number of bits in mask for EXTUI
1944    'R'  CONST_INT, print (X & 0x1f)
1945    'L'  CONST_INT, print ((32 - X) & 0x1f)
1946    'D'  REG, print second register of double-word register operand
1947    'N'  MEM, print address of next word following a memory operand
1948    'v'  MEM, if memory reference is volatile, output a MEMW before it
1949    't'  any constant, add "@h" suffix for top 16 bits
1950    'b'  any constant, add "@l" suffix for bottom 16 bits
1951 */
1952
1953 static void
1954 printx (FILE *file, signed int val)
1955 {
1956   /* Print a hexadecimal value in a nice way.  */
1957   if ((val > -0xa) && (val < 0xa))
1958     fprintf (file, "%d", val);
1959   else if (val < 0)
1960     fprintf (file, "-0x%x", -val);
1961   else
1962     fprintf (file, "0x%x", val);
1963 }
1964
1965
1966 void
1967 print_operand (FILE *file, rtx x, int letter)
1968 {
1969   if (!x)
1970     error ("PRINT_OPERAND null pointer");
1971
1972   switch (letter)
1973     {
1974     case 'D':
1975       if (GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
1976         fprintf (file, "%s", reg_names[xt_true_regnum (x) + 1]);
1977       else
1978         output_operand_lossage ("invalid %%D value");
1979       break;
1980
1981     case 'v':
1982       if (GET_CODE (x) == MEM)
1983         {
1984           /* For a volatile memory reference, emit a MEMW before the
1985              load or store.  */
1986           if (MEM_VOLATILE_P (x))
1987             fprintf (file, "memw\n\t");
1988         }
1989       else
1990         output_operand_lossage ("invalid %%v value");
1991       break;
1992
1993     case 'N':
1994       if (GET_CODE (x) == MEM
1995           && (GET_MODE (x) == DFmode || GET_MODE (x) == DImode))
1996         {
1997           x = adjust_address (x, GET_MODE (x) == DFmode ? SFmode : SImode, 4);
1998           output_address (XEXP (x, 0));
1999         }
2000       else
2001         output_operand_lossage ("invalid %%N value");
2002       break;
2003
2004     case 'K':
2005       if (GET_CODE (x) == CONST_INT)
2006         {
2007           int num_bits = 0;
2008           unsigned val = INTVAL (x);
2009           while (val & 1)
2010             {
2011               num_bits += 1;
2012               val = val >> 1;
2013             }
2014           if ((val != 0) || (num_bits == 0) || (num_bits > 16))
2015             fatal_insn ("invalid mask", x);
2016
2017           fprintf (file, "%d", num_bits);
2018         }
2019       else
2020         output_operand_lossage ("invalid %%K value");
2021       break;
2022
2023     case 'L':
2024       if (GET_CODE (x) == CONST_INT)
2025         fprintf (file, "%ld", (32 - INTVAL (x)) & 0x1f);
2026       else
2027         output_operand_lossage ("invalid %%L value");
2028       break;
2029
2030     case 'R':
2031       if (GET_CODE (x) == CONST_INT)
2032         fprintf (file, "%ld", INTVAL (x) & 0x1f);
2033       else
2034         output_operand_lossage ("invalid %%R value");
2035       break;
2036
2037     case 'x':
2038       if (GET_CODE (x) == CONST_INT)
2039         printx (file, INTVAL (x));
2040       else
2041         output_operand_lossage ("invalid %%x value");
2042       break;
2043
2044     case 'd':
2045       if (GET_CODE (x) == CONST_INT)
2046         fprintf (file, "%ld", INTVAL (x));
2047       else
2048         output_operand_lossage ("invalid %%d value");
2049       break;
2050
2051     case 't':
2052     case 'b':
2053       if (GET_CODE (x) == CONST_INT)
2054         {
2055           printx (file, INTVAL (x));
2056           fputs (letter == 't' ? "@h" : "@l", file);
2057         }
2058       else if (GET_CODE (x) == CONST_DOUBLE)
2059         {
2060           REAL_VALUE_TYPE r;
2061           REAL_VALUE_FROM_CONST_DOUBLE (r, x);
2062           if (GET_MODE (x) == SFmode)
2063             {
2064               long l;
2065               REAL_VALUE_TO_TARGET_SINGLE (r, l);
2066               fprintf (file, "0x%08lx@%c", l, letter == 't' ? 'h' : 'l');
2067             }
2068           else
2069             output_operand_lossage ("invalid %%t/%%b value");
2070         }
2071       else if (GET_CODE (x) == CONST)
2072         {
2073           /* X must be a symbolic constant on ELF.  Write an expression
2074              suitable for 'const16' that sets the high or low 16 bits.  */
2075           if (GET_CODE (XEXP (x, 0)) != PLUS
2076               || (GET_CODE (XEXP (XEXP (x, 0), 0)) != SYMBOL_REF
2077                   && GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
2078               || GET_CODE (XEXP (XEXP (x, 0), 1)) != CONST_INT)
2079             output_operand_lossage ("invalid %%t/%%b value");
2080           print_operand (file, XEXP (XEXP (x, 0), 0), 0);
2081           fputs (letter == 't' ? "@h" : "@l", file);
2082           /* There must be a non-alphanumeric character between 'h' or 'l'
2083              and the number.  The '-' is added by print_operand() already.  */
2084           if (INTVAL (XEXP (XEXP (x, 0), 1)) >= 0)
2085             fputs ("+", file);
2086           print_operand (file, XEXP (XEXP (x, 0), 1), 0);
2087         }
2088       else
2089         {
2090           output_addr_const (file, x);
2091           fputs (letter == 't' ? "@h" : "@l", file);
2092         }
2093       break;
2094
2095     default:
2096       if (GET_CODE (x) == REG || GET_CODE (x) == SUBREG)
2097         fprintf (file, "%s", reg_names[xt_true_regnum (x)]);
2098       else if (GET_CODE (x) == MEM)
2099         output_address (XEXP (x, 0));
2100       else if (GET_CODE (x) == CONST_INT)
2101         fprintf (file, "%ld", INTVAL (x));
2102       else
2103         output_addr_const (file, x);
2104     }
2105 }
2106
2107
2108 /* A C compound statement to output to stdio stream STREAM the
2109    assembler syntax for an instruction operand that is a memory
2110    reference whose address is ADDR.  ADDR is an RTL expression.  */
2111
2112 void
2113 print_operand_address (FILE *file, rtx addr)
2114 {
2115   if (!addr)
2116     error ("PRINT_OPERAND_ADDRESS, null pointer");
2117
2118   switch (GET_CODE (addr))
2119     {
2120     default:
2121       fatal_insn ("invalid address", addr);
2122       break;
2123
2124     case REG:
2125       fprintf (file, "%s, 0", reg_names [REGNO (addr)]);
2126       break;
2127
2128     case PLUS:
2129       {
2130         rtx reg = (rtx)0;
2131         rtx offset = (rtx)0;
2132         rtx arg0 = XEXP (addr, 0);
2133         rtx arg1 = XEXP (addr, 1);
2134
2135         if (GET_CODE (arg0) == REG)
2136           {
2137             reg = arg0;
2138             offset = arg1;
2139           }
2140         else if (GET_CODE (arg1) == REG)
2141           {
2142             reg = arg1;
2143             offset = arg0;
2144           }
2145         else
2146           fatal_insn ("no register in address", addr);
2147
2148         if (CONSTANT_P (offset))
2149           {
2150             fprintf (file, "%s, ", reg_names [REGNO (reg)]);
2151             output_addr_const (file, offset);
2152           }
2153         else
2154           fatal_insn ("address offset not a constant", addr);
2155       }
2156       break;
2157
2158     case LABEL_REF:
2159     case SYMBOL_REF:
2160     case CONST_INT:
2161     case CONST:
2162       output_addr_const (file, addr);
2163       break;
2164     }
2165 }
2166
2167
2168 void
2169 xtensa_output_literal (FILE *file, rtx x, enum machine_mode mode, int labelno)
2170 {
2171   long value_long[2];
2172   REAL_VALUE_TYPE r;
2173   int size;
2174
2175   fprintf (file, "\t.literal .LC%u, ", (unsigned) labelno);
2176
2177   switch (GET_MODE_CLASS (mode))
2178     {
2179     case MODE_FLOAT:
2180       if (GET_CODE (x) != CONST_DOUBLE)
2181         abort ();
2182
2183       REAL_VALUE_FROM_CONST_DOUBLE (r, x);
2184       switch (mode)
2185         {
2186         case SFmode:
2187           REAL_VALUE_TO_TARGET_SINGLE (r, value_long[0]);
2188           fprintf (file, "0x%08lx\n", value_long[0]);
2189           break;
2190
2191         case DFmode:
2192           REAL_VALUE_TO_TARGET_DOUBLE (r, value_long);
2193           fprintf (file, "0x%08lx, 0x%08lx\n",
2194                    value_long[0], value_long[1]);
2195           break;
2196
2197         default:
2198           abort ();
2199         }
2200
2201       break;
2202
2203     case MODE_INT:
2204     case MODE_PARTIAL_INT:
2205       size = GET_MODE_SIZE (mode);
2206       if (size == 4)
2207         {
2208           output_addr_const (file, x);
2209           fputs ("\n", file);
2210         }
2211       else if (size == 8)
2212         {
2213           output_addr_const (file, operand_subword (x, 0, 0, DImode));
2214           fputs (", ", file);
2215           output_addr_const (file, operand_subword (x, 1, 0, DImode));
2216           fputs ("\n", file);
2217         }
2218       else
2219         abort ();
2220       break;
2221
2222     default:
2223       abort ();
2224     }
2225 }
2226
2227
2228 /* Return the bytes needed to compute the frame pointer from the current
2229    stack pointer.  */
2230
2231 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
2232 #define XTENSA_STACK_ALIGN(LOC) (((LOC) + STACK_BYTES-1) & ~(STACK_BYTES-1))
2233
2234 long
2235 compute_frame_size (int size)
2236 {
2237   /* Add space for the incoming static chain value.  */
2238   if (cfun->static_chain_decl != NULL)
2239     size += (1 * UNITS_PER_WORD);
2240
2241   xtensa_current_frame_size =
2242     XTENSA_STACK_ALIGN (size
2243                         + current_function_outgoing_args_size
2244                         + (WINDOW_SIZE * UNITS_PER_WORD));
2245   return xtensa_current_frame_size;
2246 }
2247
2248
2249 int
2250 xtensa_frame_pointer_required (void)
2251 {
2252   /* The code to expand builtin_frame_addr and builtin_return_addr
2253      currently uses the hard_frame_pointer instead of frame_pointer.
2254      This seems wrong but maybe it's necessary for other architectures.
2255      This function is derived from the i386 code.  */
2256
2257   if (cfun->machine->accesses_prev_frame)
2258     return 1;
2259
2260   return 0;
2261 }
2262
2263
2264 void
2265 xtensa_expand_prologue (void)
2266 {
2267   HOST_WIDE_INT total_size;
2268   rtx size_rtx;
2269
2270   total_size = compute_frame_size (get_frame_size ());
2271   size_rtx = GEN_INT (total_size);
2272
2273   if (total_size < (1 << (12+3)))
2274     emit_insn (gen_entry (size_rtx, size_rtx));
2275   else
2276     {
2277       /* Use a8 as a temporary since a0-a7 may be live.  */
2278       rtx tmp_reg = gen_rtx_REG (Pmode, A8_REG);
2279       emit_insn (gen_entry (size_rtx, GEN_INT (MIN_FRAME_SIZE)));
2280       emit_move_insn (tmp_reg, GEN_INT (total_size - MIN_FRAME_SIZE));
2281       emit_insn (gen_subsi3 (tmp_reg, stack_pointer_rtx, tmp_reg));
2282       emit_move_insn (stack_pointer_rtx, tmp_reg);
2283     }
2284
2285   if (frame_pointer_needed)
2286     {
2287       if (cfun->machine->set_frame_ptr_insn)
2288         {
2289           rtx first, insn;
2290
2291           push_topmost_sequence ();
2292           first = get_insns ();
2293           pop_topmost_sequence ();
2294
2295           /* For all instructions prior to set_frame_ptr_insn, replace
2296              hard_frame_pointer references with stack_pointer.  */
2297           for (insn = first;
2298                insn != cfun->machine->set_frame_ptr_insn;
2299                insn = NEXT_INSN (insn))
2300             {
2301               if (INSN_P (insn))
2302                 PATTERN (insn) = replace_rtx (copy_rtx (PATTERN (insn)),
2303                                               hard_frame_pointer_rtx,
2304                                               stack_pointer_rtx);
2305             }
2306         }
2307       else
2308         emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx);
2309     }
2310 }
2311
2312
2313 /* Clear variables at function end.  */
2314
2315 void
2316 xtensa_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
2317                           HOST_WIDE_INT size ATTRIBUTE_UNUSED)
2318 {
2319   xtensa_current_frame_size = 0;
2320 }
2321
2322
2323 rtx
2324 xtensa_return_addr (int count, rtx frame)
2325 {
2326   rtx result, retaddr;
2327
2328   if (count == -1)
2329     retaddr = gen_rtx_REG (Pmode, A0_REG);
2330   else
2331     {
2332       rtx addr = plus_constant (frame, -4 * UNITS_PER_WORD);
2333       addr = memory_address (Pmode, addr);
2334       retaddr = gen_reg_rtx (Pmode);
2335       emit_move_insn (retaddr, gen_rtx_MEM (Pmode, addr));
2336     }
2337
2338   /* The 2 most-significant bits of the return address on Xtensa hold
2339      the register window size.  To get the real return address, these
2340      bits must be replaced with the high bits from the current PC.  */
2341
2342   result = gen_reg_rtx (Pmode);
2343   emit_insn (gen_fix_return_addr (result, retaddr));
2344   return result;
2345 }
2346
2347
2348 /* Create the va_list data type.
2349
2350    This structure is set up by __builtin_saveregs.  The __va_reg field
2351    points to a stack-allocated region holding the contents of the
2352    incoming argument registers.  The __va_ndx field is an index
2353    initialized to the position of the first unnamed (variable)
2354    argument.  This same index is also used to address the arguments
2355    passed in memory.  Thus, the __va_stk field is initialized to point
2356    to the position of the first argument in memory offset to account
2357    for the arguments passed in registers and to account for the size
2358    of the argument registers not being 16-byte aligned.  E.G., there
2359    are 6 argument registers of 4 bytes each, but we want the __va_ndx
2360    for the first stack argument to have the maximal alignment of 16
2361    bytes, so we offset the __va_stk address by 32 bytes so that
2362    __va_stk[32] references the first argument on the stack.  */
2363
2364 static tree
2365 xtensa_build_builtin_va_list (void)
2366 {
2367   tree f_stk, f_reg, f_ndx, record, type_decl;
2368
2369   record = (*lang_hooks.types.make_type) (RECORD_TYPE);
2370   type_decl = build_decl (TYPE_DECL, get_identifier ("__va_list_tag"), record);
2371
2372   f_stk = build_decl (FIELD_DECL, get_identifier ("__va_stk"),
2373                       ptr_type_node);
2374   f_reg = build_decl (FIELD_DECL, get_identifier ("__va_reg"),
2375                       ptr_type_node);
2376   f_ndx = build_decl (FIELD_DECL, get_identifier ("__va_ndx"),
2377                       integer_type_node);
2378
2379   DECL_FIELD_CONTEXT (f_stk) = record;
2380   DECL_FIELD_CONTEXT (f_reg) = record;
2381   DECL_FIELD_CONTEXT (f_ndx) = record;
2382
2383   TREE_CHAIN (record) = type_decl;
2384   TYPE_NAME (record) = type_decl;
2385   TYPE_FIELDS (record) = f_stk;
2386   TREE_CHAIN (f_stk) = f_reg;
2387   TREE_CHAIN (f_reg) = f_ndx;
2388
2389   layout_type (record);
2390   return record;
2391 }
2392
2393
2394 /* Save the incoming argument registers on the stack.  Returns the
2395    address of the saved registers.  */
2396
2397 static rtx
2398 xtensa_builtin_saveregs (void)
2399 {
2400   rtx gp_regs, dest;
2401   int arg_words = current_function_args_info.arg_words;
2402   int gp_left = MAX_ARGS_IN_REGISTERS - arg_words;
2403
2404   if (gp_left <= 0)
2405     return const0_rtx;
2406
2407   /* Allocate the general-purpose register space.  */
2408   gp_regs = assign_stack_local
2409     (BLKmode, MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD, -1);
2410   set_mem_alias_set (gp_regs, get_varargs_alias_set ());
2411
2412   /* Now store the incoming registers.  */
2413   dest = change_address (gp_regs, SImode,
2414                          plus_constant (XEXP (gp_regs, 0),
2415                                         arg_words * UNITS_PER_WORD));
2416   cfun->machine->need_a7_copy = true;
2417   cfun->machine->vararg_a7 = true;
2418   move_block_from_reg (GP_ARG_FIRST + arg_words, dest, gp_left);
2419
2420   return XEXP (gp_regs, 0);
2421 }
2422
2423
2424 /* Implement `va_start' for varargs and stdarg.  We look at the
2425    current function to fill in an initial va_list.  */
2426
2427 void
2428 xtensa_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
2429 {
2430   tree f_stk, stk;
2431   tree f_reg, reg;
2432   tree f_ndx, ndx;
2433   tree t, u;
2434   int arg_words;
2435
2436   arg_words = current_function_args_info.arg_words;
2437
2438   f_stk = TYPE_FIELDS (va_list_type_node);
2439   f_reg = TREE_CHAIN (f_stk);
2440   f_ndx = TREE_CHAIN (f_reg);
2441
2442   stk = build (COMPONENT_REF, TREE_TYPE (f_stk), valist, f_stk, NULL_TREE);
2443   reg = build (COMPONENT_REF, TREE_TYPE (f_reg), valist, f_reg, NULL_TREE);
2444   ndx = build (COMPONENT_REF, TREE_TYPE (f_ndx), valist, f_ndx, NULL_TREE);
2445
2446   /* Call __builtin_saveregs; save the result in __va_reg */
2447   u = make_tree (ptr_type_node, expand_builtin_saveregs ());
2448   t = build (MODIFY_EXPR, ptr_type_node, reg, u);
2449   TREE_SIDE_EFFECTS (t) = 1;
2450   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2451
2452   /* Set the __va_stk member to ($arg_ptr - 32).  */
2453   u = make_tree (ptr_type_node, virtual_incoming_args_rtx);
2454   u = fold (build (PLUS_EXPR, ptr_type_node, u, build_int_2 (-32, -1)));
2455   t = build (MODIFY_EXPR, ptr_type_node, stk, u);
2456   TREE_SIDE_EFFECTS (t) = 1;
2457   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2458
2459   /* Set the __va_ndx member.  If the first variable argument is on
2460      the stack, adjust __va_ndx by 2 words to account for the extra
2461      alignment offset for __va_stk.  */
2462   if (arg_words >= MAX_ARGS_IN_REGISTERS)
2463     arg_words += 2;
2464   u = build_int_2 (arg_words * UNITS_PER_WORD, 0);
2465   t = build (MODIFY_EXPR, integer_type_node, ndx, u);
2466   TREE_SIDE_EFFECTS (t) = 1;
2467   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2468 }
2469
2470
2471 /* Implement `va_arg'.  */
2472
2473 static tree
2474 xtensa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p,
2475                              tree *post_p ATTRIBUTE_UNUSED)
2476 {
2477   tree f_stk, stk;
2478   tree f_reg, reg;
2479   tree f_ndx, ndx;
2480   tree type_size, array, orig_ndx, addr, size, va_size, t;
2481   tree lab_false, lab_over, lab_false2;
2482
2483   /* Handle complex values as separate real and imaginary parts.  */
2484   if (TREE_CODE (type) == COMPLEX_TYPE)
2485     {
2486       tree real_part, imag_part;
2487
2488       real_part = xtensa_gimplify_va_arg_expr (valist, TREE_TYPE (type),
2489                                                pre_p, NULL);
2490       real_part = get_initialized_tmp_var (real_part, pre_p, NULL);
2491
2492       imag_part = xtensa_gimplify_va_arg_expr (valist, TREE_TYPE (type),
2493                                                pre_p, NULL);
2494       imag_part = get_initialized_tmp_var (imag_part, pre_p, NULL);
2495
2496       return build (COMPLEX_EXPR, type, real_part, imag_part);
2497     }
2498
2499   f_stk = TYPE_FIELDS (va_list_type_node);
2500   f_reg = TREE_CHAIN (f_stk);
2501   f_ndx = TREE_CHAIN (f_reg);
2502
2503   stk = build (COMPONENT_REF, TREE_TYPE (f_stk), valist, f_stk, NULL_TREE);
2504   reg = build (COMPONENT_REF, TREE_TYPE (f_reg), valist, f_reg, NULL_TREE);
2505   ndx = build (COMPONENT_REF, TREE_TYPE (f_ndx), valist, f_ndx, NULL_TREE);
2506
2507   type_size = size_in_bytes (type);
2508   va_size = round_up (type_size, UNITS_PER_WORD);
2509   gimplify_expr (&va_size, pre_p, NULL, is_gimple_val, fb_rvalue);
2510
2511
2512   /* First align __va_ndx if necessary for this arg:
2513
2514      orig_ndx = (AP).__va_ndx;
2515      if (__alignof__ (TYPE) > 4 )
2516        orig_ndx = ((orig_ndx + __alignof__ (TYPE) - 1)
2517                         & -__alignof__ (TYPE)); */
2518
2519   orig_ndx = get_initialized_tmp_var (ndx, pre_p, NULL);
2520
2521   if (TYPE_ALIGN (type) > BITS_PER_WORD)
2522     {
2523       int align = TYPE_ALIGN (type) / BITS_PER_UNIT;
2524
2525       t = build (PLUS_EXPR, integer_type_node, orig_ndx,
2526                  build_int_2 (align - 1, 0));
2527       t = build (BIT_AND_EXPR, integer_type_node, t,
2528                  build_int_2 (-align, -1));
2529       t = build (MODIFY_EXPR, integer_type_node, orig_ndx, t);
2530       gimplify_and_add (t, pre_p);
2531     }
2532
2533
2534   /* Increment __va_ndx to point past the argument:
2535
2536      (AP).__va_ndx = orig_ndx + __va_size (TYPE); */
2537
2538   t = fold_convert (integer_type_node, va_size);
2539   t = build (PLUS_EXPR, integer_type_node, orig_ndx, t);
2540   t = build (MODIFY_EXPR, integer_type_node, ndx, t);
2541   gimplify_and_add (t, pre_p);
2542
2543
2544   /* Check if the argument is in registers:
2545
2546      if ((AP).__va_ndx <= __MAX_ARGS_IN_REGISTERS * 4
2547          && !must_pass_in_stack (type))
2548         __array = (AP).__va_reg; */
2549
2550   array = create_tmp_var (ptr_type_node, NULL);
2551
2552   lab_over = NULL;
2553   if (!targetm.calls.must_pass_in_stack (TYPE_MODE (type), type))
2554     {
2555       lab_false = create_artificial_label ();
2556       lab_over = create_artificial_label ();
2557
2558       t = build_int_2 (MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD, 0);
2559       t = build (GT_EXPR, boolean_type_node, ndx, t);
2560       t = build (COND_EXPR, void_type_node, t,
2561                  build (GOTO_EXPR, void_type_node, lab_false),
2562                  NULL);
2563       gimplify_and_add (t, pre_p);
2564
2565       t = build (MODIFY_EXPR, void_type_node, array, reg);
2566       gimplify_and_add (t, pre_p);
2567
2568       t = build (GOTO_EXPR, void_type_node, lab_over);
2569       gimplify_and_add (t, pre_p);
2570
2571       t = build (LABEL_EXPR, void_type_node, lab_false);
2572       gimplify_and_add (t, pre_p);
2573     }
2574
2575
2576   /* ...otherwise, the argument is on the stack (never split between
2577      registers and the stack -- change __va_ndx if necessary):
2578
2579      else
2580        {
2581          if (orig_ndx <= __MAX_ARGS_IN_REGISTERS * 4)
2582              (AP).__va_ndx = 32 + __va_size (TYPE);
2583          __array = (AP).__va_stk;
2584        } */
2585
2586   lab_false2 = create_artificial_label ();
2587
2588   t = build_int_2 (MAX_ARGS_IN_REGISTERS * UNITS_PER_WORD, 0);
2589   t = build (GT_EXPR, boolean_type_node, orig_ndx, t);
2590   t = build (COND_EXPR, void_type_node, t,
2591              build (GOTO_EXPR, void_type_node, lab_false2),
2592              NULL);
2593   gimplify_and_add (t, pre_p);
2594
2595   t = size_binop (PLUS_EXPR, va_size, size_int (32));
2596   t = fold_convert (integer_type_node, t);
2597   t = build (MODIFY_EXPR, integer_type_node, ndx, t);
2598   gimplify_and_add (t, pre_p);
2599
2600   t = build (LABEL_EXPR, void_type_node, lab_false2);
2601   gimplify_and_add (t, pre_p);
2602
2603   t = build (MODIFY_EXPR, void_type_node, array, stk);
2604   gimplify_and_add (t, pre_p);
2605
2606   if (lab_over)
2607     {
2608       t = build (LABEL_EXPR, void_type_node, lab_over);
2609       gimplify_and_add (t, pre_p);
2610     }
2611
2612
2613   /* Given the base array pointer (__array) and index to the subsequent
2614      argument (__va_ndx), find the address:
2615
2616      __array + (AP).__va_ndx - (BYTES_BIG_ENDIAN && sizeof (TYPE) < 4
2617                                 ? sizeof (TYPE)
2618                                 : __va_size (TYPE))
2619
2620      The results are endian-dependent because values smaller than one word
2621      are aligned differently.  */
2622
2623
2624   if (BYTES_BIG_ENDIAN && TREE_CODE (type_size) == INTEGER_CST)
2625     {
2626       t = size_int (PARM_BOUNDARY / BITS_PER_UNIT);
2627       t = fold (build (GE_EXPR, boolean_type_node, type_size, t));
2628       t = fold (build (COND_EXPR, sizetype, t, va_size, type_size));
2629       size = t;
2630     }
2631   else
2632     size = va_size;
2633
2634   t = fold_convert (ptr_type_node, ndx);
2635   addr = build (PLUS_EXPR, ptr_type_node, array, t);
2636   t = fold_convert (ptr_type_node, size);
2637   addr = build (MINUS_EXPR, ptr_type_node, addr, t);
2638
2639   addr = fold_convert (build_pointer_type (type), addr);
2640   return build_fold_indirect_ref (addr);
2641 }
2642
2643
2644 enum reg_class
2645 xtensa_preferred_reload_class (rtx x, enum reg_class class, int isoutput)
2646 {
2647   if (!isoutput && CONSTANT_P (x) && GET_CODE (x) == CONST_DOUBLE)
2648     return NO_REGS;
2649
2650   /* Don't use the stack pointer or hard frame pointer for reloads!
2651      The hard frame pointer would normally be OK except that it may
2652      briefly hold an incoming argument in the prologue, and reload
2653      won't know that it is live because the hard frame pointer is
2654      treated specially.  */
2655
2656   if (class == AR_REGS || class == GR_REGS)
2657     return RL_REGS;
2658
2659   return class;
2660 }
2661
2662
2663 enum reg_class
2664 xtensa_secondary_reload_class (enum reg_class class,
2665                                enum machine_mode mode ATTRIBUTE_UNUSED,
2666                                rtx x, int isoutput)
2667 {
2668   int regno;
2669
2670   if (GET_CODE (x) == SIGN_EXTEND)
2671     x = XEXP (x, 0);
2672   regno = xt_true_regnum (x);
2673
2674   if (!isoutput)
2675     {
2676       if (class == FP_REGS && constantpool_mem_p (x))
2677         return RL_REGS;
2678     }
2679
2680   if (ACC_REG_P (regno))
2681     return ((class == GR_REGS || class == RL_REGS) ? NO_REGS : RL_REGS);
2682   if (class == ACC_REG)
2683     return (GP_REG_P (regno) ? NO_REGS : RL_REGS);
2684
2685   return NO_REGS;
2686 }
2687
2688
2689 void
2690 order_regs_for_local_alloc (void)
2691 {
2692   if (!leaf_function_p ())
2693     {
2694       memcpy (reg_alloc_order, reg_nonleaf_alloc_order,
2695               FIRST_PSEUDO_REGISTER * sizeof (int));
2696     }
2697   else
2698     {
2699       int i, num_arg_regs;
2700       int nxt = 0;
2701
2702       /* Use the AR registers in increasing order (skipping a0 and a1)
2703          but save the incoming argument registers for a last resort.  */
2704       num_arg_regs = current_function_args_info.arg_words;
2705       if (num_arg_regs > MAX_ARGS_IN_REGISTERS)
2706         num_arg_regs = MAX_ARGS_IN_REGISTERS;
2707       for (i = GP_ARG_FIRST; i < 16 - num_arg_regs; i++)
2708         reg_alloc_order[nxt++] = i + num_arg_regs;
2709       for (i = 0; i < num_arg_regs; i++)
2710         reg_alloc_order[nxt++] = GP_ARG_FIRST + i;
2711
2712       /* List the coprocessor registers in order.  */
2713       for (i = 0; i < BR_REG_NUM; i++)
2714         reg_alloc_order[nxt++] = BR_REG_FIRST + i;
2715
2716       /* List the FP registers in order for now.  */
2717       for (i = 0; i < 16; i++)
2718         reg_alloc_order[nxt++] = FP_REG_FIRST + i;
2719
2720       /* GCC requires that we list *all* the registers....  */
2721       reg_alloc_order[nxt++] = 0;       /* a0 = return address */
2722       reg_alloc_order[nxt++] = 1;       /* a1 = stack pointer */
2723       reg_alloc_order[nxt++] = 16;      /* pseudo frame pointer */
2724       reg_alloc_order[nxt++] = 17;      /* pseudo arg pointer */
2725
2726       reg_alloc_order[nxt++] = ACC_REG_FIRST;   /* MAC16 accumulator */
2727     }
2728 }
2729
2730
2731 /* Some Xtensa targets support multiple bss sections.  If the section
2732    name ends with ".bss", add SECTION_BSS to the flags.  */
2733
2734 static unsigned int
2735 xtensa_multibss_section_type_flags (tree decl, const char *name, int reloc)
2736 {
2737   unsigned int flags = default_section_type_flags (decl, name, reloc);
2738   const char *suffix;
2739
2740   suffix = strrchr (name, '.');
2741   if (suffix && strcmp (suffix, ".bss") == 0)
2742     {
2743       if (!decl || (TREE_CODE (decl) == VAR_DECL
2744                     && DECL_INITIAL (decl) == NULL_TREE))
2745         flags |= SECTION_BSS;  /* @nobits */
2746       else
2747         warning ("only uninitialized variables can be placed in a "
2748                  ".bss section");
2749     }
2750
2751   return flags;
2752 }
2753
2754
2755 /* The literal pool stays with the function.  */
2756
2757 static void
2758 xtensa_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
2759                            rtx x ATTRIBUTE_UNUSED,
2760                            unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
2761 {
2762   function_section (current_function_decl);
2763 }
2764
2765
2766 /* Compute a (partial) cost for rtx X.  Return true if the complete
2767    cost has been computed, and false if subexpressions should be
2768    scanned.  In either case, *TOTAL contains the cost result.  */
2769
2770 static bool
2771 xtensa_rtx_costs (rtx x, int code, int outer_code, int *total)
2772 {
2773   switch (code)
2774     {
2775     case CONST_INT:
2776       switch (outer_code)
2777         {
2778         case SET:
2779           if (xtensa_simm12b (INTVAL (x)))
2780             {
2781               *total = 4;
2782               return true;
2783             }
2784           break;
2785         case PLUS:
2786           if (xtensa_simm8 (INTVAL (x))
2787               || xtensa_simm8x256 (INTVAL (x)))
2788             {
2789               *total = 0;
2790               return true;
2791             }
2792           break;
2793         case AND:
2794           if (xtensa_mask_immediate (INTVAL (x)))
2795             {
2796               *total = 0;
2797               return true;
2798             }
2799           break;
2800         case COMPARE:
2801           if ((INTVAL (x) == 0) || xtensa_b4const (INTVAL (x)))
2802             {
2803               *total = 0;
2804               return true;
2805             }
2806           break;
2807         case ASHIFT:
2808         case ASHIFTRT:
2809         case LSHIFTRT:
2810         case ROTATE:
2811         case ROTATERT:
2812           /* No way to tell if X is the 2nd operand so be conservative.  */
2813         default: break;
2814         }
2815       if (xtensa_simm12b (INTVAL (x)))
2816         *total = 5;
2817       else if (TARGET_CONST16)
2818         *total = COSTS_N_INSNS (2);
2819       else
2820         *total = 6;
2821       return true;
2822
2823     case CONST:
2824     case LABEL_REF:
2825     case SYMBOL_REF:
2826       if (TARGET_CONST16)
2827         *total = COSTS_N_INSNS (2);
2828       else
2829         *total = 5;
2830       return true;
2831
2832     case CONST_DOUBLE:
2833       if (TARGET_CONST16)
2834         *total = COSTS_N_INSNS (4);
2835       else
2836         *total = 7;
2837       return true;
2838
2839     case MEM:
2840       {
2841         int num_words =
2842           (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD) ?  2 : 1;
2843
2844         if (memory_address_p (GET_MODE (x), XEXP ((x), 0)))
2845           *total = COSTS_N_INSNS (num_words);
2846         else
2847           *total = COSTS_N_INSNS (2*num_words);
2848         return true;
2849       }
2850
2851     case FFS:
2852       *total = COSTS_N_INSNS (TARGET_NSA ? 5 : 50);
2853       return true;
2854
2855     case NOT:
2856       *total = COSTS_N_INSNS ((GET_MODE (x) == DImode) ? 3 : 2);
2857       return true;
2858
2859     case AND:
2860     case IOR:
2861     case XOR:
2862       if (GET_MODE (x) == DImode)
2863         *total = COSTS_N_INSNS (2);
2864       else
2865         *total = COSTS_N_INSNS (1);
2866       return true;
2867
2868     case ASHIFT:
2869     case ASHIFTRT:
2870     case LSHIFTRT:
2871       if (GET_MODE (x) == DImode)
2872         *total = COSTS_N_INSNS (50);
2873       else
2874         *total = COSTS_N_INSNS (1);
2875       return true;
2876
2877     case ABS:
2878       {
2879         enum machine_mode xmode = GET_MODE (x);
2880         if (xmode == SFmode)
2881           *total = COSTS_N_INSNS (TARGET_HARD_FLOAT ? 1 : 50);
2882         else if (xmode == DFmode)
2883           *total = COSTS_N_INSNS (50);
2884         else
2885           *total = COSTS_N_INSNS (4);
2886         return true;
2887       }
2888
2889     case PLUS:
2890     case MINUS:
2891       {
2892         enum machine_mode xmode = GET_MODE (x);
2893         if (xmode == SFmode)
2894           *total = COSTS_N_INSNS (TARGET_HARD_FLOAT ? 1 : 50);
2895         else if (xmode == DFmode || xmode == DImode)
2896           *total = COSTS_N_INSNS (50);
2897         else
2898           *total = COSTS_N_INSNS (1);
2899         return true;
2900       }
2901
2902     case NEG:
2903       *total = COSTS_N_INSNS ((GET_MODE (x) == DImode) ? 4 : 2);
2904       return true;
2905
2906     case MULT:
2907       {
2908         enum machine_mode xmode = GET_MODE (x);
2909         if (xmode == SFmode)
2910           *total = COSTS_N_INSNS (TARGET_HARD_FLOAT ? 4 : 50);
2911         else if (xmode == DFmode || xmode == DImode)
2912           *total = COSTS_N_INSNS (50);
2913         else if (TARGET_MUL32)
2914           *total = COSTS_N_INSNS (4);
2915         else if (TARGET_MAC16)
2916           *total = COSTS_N_INSNS (16);
2917         else if (TARGET_MUL16)
2918           *total = COSTS_N_INSNS (12);
2919         else
2920           *total = COSTS_N_INSNS (50);
2921         return true;
2922       }
2923
2924     case DIV:
2925     case MOD:
2926       {
2927         enum machine_mode xmode = GET_MODE (x);
2928         if (xmode == SFmode)
2929           {
2930             *total = COSTS_N_INSNS (TARGET_HARD_FLOAT_DIV ? 8 : 50);
2931             return true;
2932           }
2933         else if (xmode == DFmode)
2934           {
2935             *total = COSTS_N_INSNS (50);
2936             return true;
2937           }
2938       }
2939       /* Fall through.  */
2940
2941     case UDIV:
2942     case UMOD:
2943       {
2944         enum machine_mode xmode = GET_MODE (x);
2945         if (xmode == DImode)
2946           *total = COSTS_N_INSNS (50);
2947         else if (TARGET_DIV32)
2948           *total = COSTS_N_INSNS (32);
2949         else
2950           *total = COSTS_N_INSNS (50);
2951         return true;
2952       }
2953
2954     case SQRT:
2955       if (GET_MODE (x) == SFmode)
2956         *total = COSTS_N_INSNS (TARGET_HARD_FLOAT_SQRT ? 8 : 50);
2957       else
2958         *total = COSTS_N_INSNS (50);
2959       return true;
2960
2961     case SMIN:
2962     case UMIN:
2963     case SMAX:
2964     case UMAX:
2965       *total = COSTS_N_INSNS (TARGET_MINMAX ? 1 : 50);
2966       return true;
2967
2968     case SIGN_EXTRACT:
2969     case SIGN_EXTEND:
2970       *total = COSTS_N_INSNS (TARGET_SEXT ? 1 : 2);
2971       return true;
2972
2973     case ZERO_EXTRACT:
2974     case ZERO_EXTEND:
2975       *total = COSTS_N_INSNS (1);
2976       return true;
2977
2978     default:
2979       return false;
2980     }
2981 }
2982
2983 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
2984
2985 static bool
2986 xtensa_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
2987 {
2988   return ((unsigned HOST_WIDE_INT) int_size_in_bytes (type)
2989           > 4 * UNITS_PER_WORD);
2990 }
2991
2992 #include "gt-xtensa.h"