OSDN Git Service

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