OSDN Git Service

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