1 /* Subroutines for insn-output.c for Tensilica's Xtensa architecture.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
3 2012 Free Software Foundation, Inc.
4 Contributed by Bob Wilson (bwilson@tensilica.com) at Tensilica.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
28 #include "hard-reg-set.h"
29 #include "basic-block.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-flags.h"
33 #include "insn-attr.h"
34 #include "insn-codes.h"
43 #include "diagnostic-core.h"
48 #include "target-def.h"
49 #include "langhooks.h"
54 /* Enumeration for all of the relational tests, so that we can build
55 arrays indexed by the test type, and not worry about the order
73 /* Array giving truth value on whether or not a given hard register
74 can support a given mode. */
75 char xtensa_hard_regno_mode_ok
[(int) MAX_MACHINE_MODE
][FIRST_PSEUDO_REGISTER
];
77 /* Current frame size calculated by compute_frame_size. */
78 unsigned xtensa_current_frame_size
;
80 /* Largest block move to handle in-line. */
81 #define LARGEST_MOVE_RATIO 15
83 /* Define the structure for the machine field in struct function. */
84 struct GTY(()) machine_function
86 int accesses_prev_frame
;
90 rtx set_frame_ptr_insn
;
93 /* Vector, indexed by hard register number, which contains 1 for a
94 register that is allowable in a candidate for leaf function
97 const char xtensa_leaf_regs
[FIRST_PSEUDO_REGISTER
] =
99 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
101 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
105 /* Map hard register number to register class */
106 const enum reg_class xtensa_regno_to_class
[FIRST_PSEUDO_REGISTER
] =
108 RL_REGS
, SP_REG
, RL_REGS
, RL_REGS
,
109 RL_REGS
, RL_REGS
, RL_REGS
, GR_REGS
,
110 RL_REGS
, RL_REGS
, RL_REGS
, RL_REGS
,
111 RL_REGS
, RL_REGS
, RL_REGS
, RL_REGS
,
112 AR_REGS
, AR_REGS
, BR_REGS
,
113 FP_REGS
, FP_REGS
, FP_REGS
, FP_REGS
,
114 FP_REGS
, FP_REGS
, FP_REGS
, FP_REGS
,
115 FP_REGS
, FP_REGS
, FP_REGS
, FP_REGS
,
116 FP_REGS
, FP_REGS
, FP_REGS
, FP_REGS
,
120 static void xtensa_option_override (void);
121 static enum internal_test
map_test_to_internal_test (enum rtx_code
);
122 static rtx
gen_int_relational (enum rtx_code
, rtx
, rtx
, int *);
123 static rtx
gen_float_relational (enum rtx_code
, rtx
, rtx
);
124 static rtx
gen_conditional_move (enum rtx_code
, enum machine_mode
, rtx
, rtx
);
125 static rtx
fixup_subreg_mem (rtx
);
126 static struct machine_function
* xtensa_init_machine_status (void);
127 static rtx
xtensa_legitimize_tls_address (rtx
);
128 static rtx
xtensa_legitimize_address (rtx
, rtx
, enum machine_mode
);
129 static bool xtensa_mode_dependent_address_p (const_rtx
, addr_space_t
);
130 static bool xtensa_return_in_msb (const_tree
);
131 static void printx (FILE *, signed int);
132 static void xtensa_function_epilogue (FILE *, HOST_WIDE_INT
);
133 static rtx
xtensa_builtin_saveregs (void);
134 static bool xtensa_legitimate_address_p (enum machine_mode
, rtx
, bool);
135 static unsigned int xtensa_multibss_section_type_flags (tree
, const char *,
136 int) ATTRIBUTE_UNUSED
;
137 static section
*xtensa_select_rtx_section (enum machine_mode
, rtx
,
138 unsigned HOST_WIDE_INT
);
139 static bool xtensa_rtx_costs (rtx
, int, int, int, int *, bool);
140 static int xtensa_register_move_cost (enum machine_mode
, reg_class_t
,
142 static int xtensa_memory_move_cost (enum machine_mode
, reg_class_t
, bool);
143 static tree
xtensa_build_builtin_va_list (void);
144 static bool xtensa_return_in_memory (const_tree
, const_tree
);
145 static tree
xtensa_gimplify_va_arg_expr (tree
, tree
, gimple_seq
*,
147 static void xtensa_function_arg_advance (cumulative_args_t
, enum machine_mode
,
149 static rtx
xtensa_function_arg (cumulative_args_t
, enum machine_mode
,
151 static rtx
xtensa_function_incoming_arg (cumulative_args_t
,
152 enum machine_mode
, const_tree
, bool);
153 static rtx
xtensa_function_value (const_tree
, const_tree
, bool);
154 static rtx
xtensa_libcall_value (enum machine_mode
, const_rtx
);
155 static bool xtensa_function_value_regno_p (const unsigned int);
156 static unsigned int xtensa_function_arg_boundary (enum machine_mode
,
158 static void xtensa_init_builtins (void);
159 static tree
xtensa_fold_builtin (tree
, int, tree
*, bool);
160 static rtx
xtensa_expand_builtin (tree
, rtx
, rtx
, enum machine_mode
, int);
161 static void xtensa_va_start (tree
, rtx
);
162 static bool xtensa_frame_pointer_required (void);
163 static rtx
xtensa_static_chain (const_tree
, bool);
164 static void xtensa_asm_trampoline_template (FILE *);
165 static void xtensa_trampoline_init (rtx
, tree
, rtx
);
166 static bool xtensa_output_addr_const_extra (FILE *, rtx
);
167 static bool xtensa_cannot_force_const_mem (enum machine_mode
, rtx
);
169 static reg_class_t
xtensa_preferred_reload_class (rtx
, reg_class_t
);
170 static reg_class_t
xtensa_preferred_output_reload_class (rtx
, reg_class_t
);
171 static reg_class_t
xtensa_secondary_reload (bool, rtx
, reg_class_t
,
173 struct secondary_reload_info
*);
175 static bool constantpool_address_p (const_rtx addr
);
176 static bool xtensa_legitimate_constant_p (enum machine_mode
, rtx
);
178 static bool xtensa_member_type_forces_blk (const_tree
,
179 enum machine_mode mode
);
181 static const int reg_nonleaf_alloc_order
[FIRST_PSEUDO_REGISTER
] =
185 /* This macro generates the assembly code for function exit,
186 on machines that need it. If FUNCTION_EPILOGUE is not defined
187 then individual return instructions are generated for each
188 return statement. Args are same as for FUNCTION_PROLOGUE. */
190 #undef TARGET_ASM_FUNCTION_EPILOGUE
191 #define TARGET_ASM_FUNCTION_EPILOGUE xtensa_function_epilogue
193 /* These hooks specify assembly directives for creating certain kinds
194 of integer object. */
196 #undef TARGET_ASM_ALIGNED_SI_OP
197 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
199 #undef TARGET_ASM_SELECT_RTX_SECTION
200 #define TARGET_ASM_SELECT_RTX_SECTION xtensa_select_rtx_section
202 #undef TARGET_LEGITIMIZE_ADDRESS
203 #define TARGET_LEGITIMIZE_ADDRESS xtensa_legitimize_address
204 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
205 #define TARGET_MODE_DEPENDENT_ADDRESS_P xtensa_mode_dependent_address_p
207 #undef TARGET_REGISTER_MOVE_COST
208 #define TARGET_REGISTER_MOVE_COST xtensa_register_move_cost
209 #undef TARGET_MEMORY_MOVE_COST
210 #define TARGET_MEMORY_MOVE_COST xtensa_memory_move_cost
211 #undef TARGET_RTX_COSTS
212 #define TARGET_RTX_COSTS xtensa_rtx_costs
213 #undef TARGET_ADDRESS_COST
214 #define TARGET_ADDRESS_COST hook_int_rtx_mode_as_bool_0
216 #undef TARGET_MEMBER_TYPE_FORCES_BLK
217 #define TARGET_MEMBER_TYPE_FORCES_BLK xtensa_member_type_forces_blk
219 #undef TARGET_BUILD_BUILTIN_VA_LIST
220 #define TARGET_BUILD_BUILTIN_VA_LIST xtensa_build_builtin_va_list
222 #undef TARGET_EXPAND_BUILTIN_VA_START
223 #define TARGET_EXPAND_BUILTIN_VA_START xtensa_va_start
225 #undef TARGET_PROMOTE_FUNCTION_MODE
226 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
227 #undef TARGET_PROMOTE_PROTOTYPES
228 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
230 #undef TARGET_RETURN_IN_MEMORY
231 #define TARGET_RETURN_IN_MEMORY xtensa_return_in_memory
232 #undef TARGET_FUNCTION_VALUE
233 #define TARGET_FUNCTION_VALUE xtensa_function_value
234 #undef TARGET_LIBCALL_VALUE
235 #define TARGET_LIBCALL_VALUE xtensa_libcall_value
236 #undef TARGET_FUNCTION_VALUE_REGNO_P
237 #define TARGET_FUNCTION_VALUE_REGNO_P xtensa_function_value_regno_p
239 #undef TARGET_SPLIT_COMPLEX_ARG
240 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
241 #undef TARGET_MUST_PASS_IN_STACK
242 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
243 #undef TARGET_FUNCTION_ARG_ADVANCE
244 #define TARGET_FUNCTION_ARG_ADVANCE xtensa_function_arg_advance
245 #undef TARGET_FUNCTION_ARG
246 #define TARGET_FUNCTION_ARG xtensa_function_arg
247 #undef TARGET_FUNCTION_INCOMING_ARG
248 #define TARGET_FUNCTION_INCOMING_ARG xtensa_function_incoming_arg
249 #undef TARGET_FUNCTION_ARG_BOUNDARY
250 #define TARGET_FUNCTION_ARG_BOUNDARY xtensa_function_arg_boundary
252 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
253 #define TARGET_EXPAND_BUILTIN_SAVEREGS xtensa_builtin_saveregs
254 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
255 #define TARGET_GIMPLIFY_VA_ARG_EXPR xtensa_gimplify_va_arg_expr
257 #undef TARGET_RETURN_IN_MSB
258 #define TARGET_RETURN_IN_MSB xtensa_return_in_msb
260 #undef TARGET_INIT_BUILTINS
261 #define TARGET_INIT_BUILTINS xtensa_init_builtins
262 #undef TARGET_FOLD_BUILTIN
263 #define TARGET_FOLD_BUILTIN xtensa_fold_builtin
264 #undef TARGET_EXPAND_BUILTIN
265 #define TARGET_EXPAND_BUILTIN xtensa_expand_builtin
267 #undef TARGET_PREFERRED_RELOAD_CLASS
268 #define TARGET_PREFERRED_RELOAD_CLASS xtensa_preferred_reload_class
269 #undef TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
270 #define TARGET_PREFERRED_OUTPUT_RELOAD_CLASS xtensa_preferred_output_reload_class
272 #undef TARGET_SECONDARY_RELOAD
273 #define TARGET_SECONDARY_RELOAD xtensa_secondary_reload
275 #undef TARGET_HAVE_TLS
276 #define TARGET_HAVE_TLS (TARGET_THREADPTR && HAVE_AS_TLS)
278 #undef TARGET_CANNOT_FORCE_CONST_MEM
279 #define TARGET_CANNOT_FORCE_CONST_MEM xtensa_cannot_force_const_mem
281 #undef TARGET_LEGITIMATE_ADDRESS_P
282 #define TARGET_LEGITIMATE_ADDRESS_P xtensa_legitimate_address_p
284 #undef TARGET_FRAME_POINTER_REQUIRED
285 #define TARGET_FRAME_POINTER_REQUIRED xtensa_frame_pointer_required
287 #undef TARGET_STATIC_CHAIN
288 #define TARGET_STATIC_CHAIN xtensa_static_chain
289 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
290 #define TARGET_ASM_TRAMPOLINE_TEMPLATE xtensa_asm_trampoline_template
291 #undef TARGET_TRAMPOLINE_INIT
292 #define TARGET_TRAMPOLINE_INIT xtensa_trampoline_init
294 #undef TARGET_OPTION_OVERRIDE
295 #define TARGET_OPTION_OVERRIDE xtensa_option_override
297 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
298 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA xtensa_output_addr_const_extra
300 #undef TARGET_LEGITIMATE_CONSTANT_P
301 #define TARGET_LEGITIMATE_CONSTANT_P xtensa_legitimate_constant_p
303 struct gcc_target targetm
= TARGET_INITIALIZER
;
306 /* Functions to test Xtensa immediate operand validity. */
309 xtensa_simm8 (HOST_WIDE_INT v
)
311 return v
>= -128 && v
<= 127;
316 xtensa_simm8x256 (HOST_WIDE_INT v
)
318 return (v
& 255) == 0 && (v
>= -32768 && v
<= 32512);
323 xtensa_simm12b (HOST_WIDE_INT v
)
325 return v
>= -2048 && v
<= 2047;
330 xtensa_uimm8 (HOST_WIDE_INT v
)
332 return v
>= 0 && v
<= 255;
337 xtensa_uimm8x2 (HOST_WIDE_INT v
)
339 return (v
& 1) == 0 && (v
>= 0 && v
<= 510);
344 xtensa_uimm8x4 (HOST_WIDE_INT v
)
346 return (v
& 3) == 0 && (v
>= 0 && v
<= 1020);
351 xtensa_b4const (HOST_WIDE_INT v
)
378 xtensa_b4const_or_zero (HOST_WIDE_INT v
)
382 return xtensa_b4const (v
);
387 xtensa_b4constu (HOST_WIDE_INT v
)
414 xtensa_mask_immediate (HOST_WIDE_INT v
)
416 #define MAX_MASK_SIZE 16
419 for (mask_size
= 1; mask_size
<= MAX_MASK_SIZE
; mask_size
++)
432 /* This is just like the standard true_regnum() function except that it
433 works even when reg_renumber is not initialized. */
436 xt_true_regnum (rtx x
)
438 if (GET_CODE (x
) == REG
)
441 && REGNO (x
) >= FIRST_PSEUDO_REGISTER
442 && reg_renumber
[REGNO (x
)] >= 0)
443 return reg_renumber
[REGNO (x
)];
446 if (GET_CODE (x
) == SUBREG
)
448 int base
= xt_true_regnum (SUBREG_REG (x
));
449 if (base
>= 0 && base
< FIRST_PSEUDO_REGISTER
)
450 return base
+ subreg_regno_offset (REGNO (SUBREG_REG (x
)),
451 GET_MODE (SUBREG_REG (x
)),
452 SUBREG_BYTE (x
), GET_MODE (x
));
459 xtensa_valid_move (enum machine_mode mode
, rtx
*operands
)
461 /* Either the destination or source must be a register, and the
462 MAC16 accumulator doesn't count. */
464 if (register_operand (operands
[0], mode
))
466 int dst_regnum
= xt_true_regnum (operands
[0]);
468 /* The stack pointer can only be assigned with a MOVSP opcode. */
469 if (dst_regnum
== STACK_POINTER_REGNUM
)
470 return (mode
== SImode
471 && register_operand (operands
[1], mode
)
472 && !ACC_REG_P (xt_true_regnum (operands
[1])));
474 if (!ACC_REG_P (dst_regnum
))
477 if (register_operand (operands
[1], mode
))
479 int src_regnum
= xt_true_regnum (operands
[1]);
480 if (!ACC_REG_P (src_regnum
))
488 smalloffset_mem_p (rtx op
)
490 if (GET_CODE (op
) == MEM
)
492 rtx addr
= XEXP (op
, 0);
493 if (GET_CODE (addr
) == REG
)
494 return BASE_REG_P (addr
, 0);
495 if (GET_CODE (addr
) == PLUS
)
497 rtx offset
= XEXP (addr
, 0);
499 if (GET_CODE (offset
) != CONST_INT
)
500 offset
= XEXP (addr
, 1);
501 if (GET_CODE (offset
) != CONST_INT
)
504 val
= INTVAL (offset
);
505 return (val
& 3) == 0 && (val
>= 0 && val
<= 60);
513 constantpool_address_p (const_rtx addr
)
515 const_rtx sym
= addr
;
517 if (GET_CODE (addr
) == CONST
)
521 /* Only handle (PLUS (SYM, OFFSET)) form. */
522 addr
= XEXP (addr
, 0);
523 if (GET_CODE (addr
) != PLUS
)
526 /* Make sure the address is word aligned. */
527 offset
= XEXP (addr
, 1);
528 if ((!CONST_INT_P (offset
))
529 || ((INTVAL (offset
) & 3) != 0))
532 sym
= XEXP (addr
, 0);
535 if ((GET_CODE (sym
) == SYMBOL_REF
)
536 && CONSTANT_POOL_ADDRESS_P (sym
))
543 constantpool_mem_p (rtx op
)
545 if (GET_CODE (op
) == SUBREG
)
546 op
= SUBREG_REG (op
);
547 if (GET_CODE (op
) == MEM
)
548 return constantpool_address_p (XEXP (op
, 0));
553 /* Return TRUE if X is a thread-local symbol. */
556 xtensa_tls_symbol_p (rtx x
)
558 if (! TARGET_HAVE_TLS
)
561 return GET_CODE (x
) == SYMBOL_REF
&& SYMBOL_REF_TLS_MODEL (x
) != 0;
566 xtensa_extend_reg (rtx dst
, rtx src
)
568 rtx temp
= gen_reg_rtx (SImode
);
569 rtx shift
= GEN_INT (BITS_PER_WORD
- GET_MODE_BITSIZE (GET_MODE (src
)));
571 /* Generate paradoxical subregs as needed so that the modes match. */
572 src
= simplify_gen_subreg (SImode
, src
, GET_MODE (src
), 0);
573 dst
= simplify_gen_subreg (SImode
, dst
, GET_MODE (dst
), 0);
575 emit_insn (gen_ashlsi3 (temp
, src
, shift
));
576 emit_insn (gen_ashrsi3 (dst
, temp
, shift
));
581 xtensa_mem_offset (unsigned v
, enum machine_mode mode
)
586 /* Handle the worst case for block moves. See xtensa_expand_block_move
587 where we emit an optimized block move operation if the block can be
588 moved in < "move_ratio" pieces. The worst case is when the block is
589 aligned but has a size of (3 mod 4) (does this happen?) so that the
590 last piece requires a byte load/store. */
591 return (xtensa_uimm8 (v
)
592 && xtensa_uimm8 (v
+ MOVE_MAX
* LARGEST_MOVE_RATIO
));
595 return xtensa_uimm8 (v
);
598 return xtensa_uimm8x2 (v
);
601 return (xtensa_uimm8x4 (v
) && xtensa_uimm8x4 (v
+ 4));
607 return xtensa_uimm8x4 (v
);
611 /* Make normal rtx_code into something we can index from an array. */
613 static enum internal_test
614 map_test_to_internal_test (enum rtx_code test_code
)
616 enum internal_test test
= ITEST_MAX
;
621 case EQ
: test
= ITEST_EQ
; break;
622 case NE
: test
= ITEST_NE
; break;
623 case GT
: test
= ITEST_GT
; break;
624 case GE
: test
= ITEST_GE
; break;
625 case LT
: test
= ITEST_LT
; break;
626 case LE
: test
= ITEST_LE
; break;
627 case GTU
: test
= ITEST_GTU
; break;
628 case GEU
: test
= ITEST_GEU
; break;
629 case LTU
: test
= ITEST_LTU
; break;
630 case LEU
: test
= ITEST_LEU
; break;
637 /* Generate the code to compare two integer values. The return value is
638 the comparison expression. */
641 gen_int_relational (enum rtx_code test_code
, /* relational test (EQ, etc) */
642 rtx cmp0
, /* first operand to compare */
643 rtx cmp1
, /* second operand to compare */
644 int *p_invert
/* whether branch needs to reverse test */)
648 enum rtx_code test_code
; /* test code to use in insn */
649 bool (*const_range_p
) (HOST_WIDE_INT
); /* range check function */
650 int const_add
; /* constant to add (convert LE -> LT) */
651 int reverse_regs
; /* reverse registers in test */
652 int invert_const
; /* != 0 if invert value if cmp1 is constant */
653 int invert_reg
; /* != 0 if invert value if cmp1 is register */
654 int unsignedp
; /* != 0 for unsigned comparisons. */
657 static struct cmp_info info
[ (int)ITEST_MAX
] = {
659 { EQ
, xtensa_b4const_or_zero
, 0, 0, 0, 0, 0 }, /* EQ */
660 { NE
, xtensa_b4const_or_zero
, 0, 0, 0, 0, 0 }, /* NE */
662 { LT
, xtensa_b4const_or_zero
, 1, 1, 1, 0, 0 }, /* GT */
663 { GE
, xtensa_b4const_or_zero
, 0, 0, 0, 0, 0 }, /* GE */
664 { LT
, xtensa_b4const_or_zero
, 0, 0, 0, 0, 0 }, /* LT */
665 { GE
, xtensa_b4const_or_zero
, 1, 1, 1, 0, 0 }, /* LE */
667 { LTU
, xtensa_b4constu
, 1, 1, 1, 0, 1 }, /* GTU */
668 { GEU
, xtensa_b4constu
, 0, 0, 0, 0, 1 }, /* GEU */
669 { LTU
, xtensa_b4constu
, 0, 0, 0, 0, 1 }, /* LTU */
670 { GEU
, xtensa_b4constu
, 1, 1, 1, 0, 1 }, /* LEU */
673 enum internal_test test
;
674 enum machine_mode mode
;
675 struct cmp_info
*p_info
;
677 test
= map_test_to_internal_test (test_code
);
678 gcc_assert (test
!= ITEST_MAX
);
680 p_info
= &info
[ (int)test
];
682 mode
= GET_MODE (cmp0
);
683 if (mode
== VOIDmode
)
684 mode
= GET_MODE (cmp1
);
686 /* Make sure we can handle any constants given to us. */
687 if (GET_CODE (cmp1
) == CONST_INT
)
689 HOST_WIDE_INT value
= INTVAL (cmp1
);
690 unsigned HOST_WIDE_INT uvalue
= (unsigned HOST_WIDE_INT
)value
;
692 /* if the immediate overflows or does not fit in the immediate field,
693 spill it to a register */
695 if ((p_info
->unsignedp
?
696 (uvalue
+ p_info
->const_add
> uvalue
) :
697 (value
+ p_info
->const_add
> value
)) != (p_info
->const_add
> 0))
699 cmp1
= force_reg (mode
, cmp1
);
701 else if (!(p_info
->const_range_p
) (value
+ p_info
->const_add
))
703 cmp1
= force_reg (mode
, cmp1
);
706 else if ((GET_CODE (cmp1
) != REG
) && (GET_CODE (cmp1
) != SUBREG
))
708 cmp1
= force_reg (mode
, cmp1
);
711 /* See if we need to invert the result. */
712 *p_invert
= ((GET_CODE (cmp1
) == CONST_INT
)
713 ? p_info
->invert_const
714 : p_info
->invert_reg
);
716 /* Comparison to constants, may involve adding 1 to change a LT into LE.
717 Comparison between two registers, may involve switching operands. */
718 if (GET_CODE (cmp1
) == CONST_INT
)
720 if (p_info
->const_add
!= 0)
721 cmp1
= GEN_INT (INTVAL (cmp1
) + p_info
->const_add
);
724 else if (p_info
->reverse_regs
)
731 return gen_rtx_fmt_ee (p_info
->test_code
, VOIDmode
, cmp0
, cmp1
);
735 /* Generate the code to compare two float values. The return value is
736 the comparison expression. */
739 gen_float_relational (enum rtx_code test_code
, /* relational test (EQ, etc) */
740 rtx cmp0
, /* first operand to compare */
741 rtx cmp1
/* second operand to compare */)
743 rtx (*gen_fn
) (rtx
, rtx
, rtx
);
745 int reverse_regs
, invert
;
749 case EQ
: reverse_regs
= 0; invert
= 0; gen_fn
= gen_seq_sf
; break;
750 case NE
: reverse_regs
= 0; invert
= 1; gen_fn
= gen_seq_sf
; break;
751 case LE
: reverse_regs
= 0; invert
= 0; gen_fn
= gen_sle_sf
; break;
752 case GT
: reverse_regs
= 1; invert
= 0; gen_fn
= gen_slt_sf
; break;
753 case LT
: reverse_regs
= 0; invert
= 0; gen_fn
= gen_slt_sf
; break;
754 case GE
: reverse_regs
= 1; invert
= 0; gen_fn
= gen_sle_sf
; break;
755 case UNEQ
: reverse_regs
= 0; invert
= 0; gen_fn
= gen_suneq_sf
; break;
756 case LTGT
: reverse_regs
= 0; invert
= 1; gen_fn
= gen_suneq_sf
; break;
757 case UNLE
: reverse_regs
= 0; invert
= 0; gen_fn
= gen_sunle_sf
; break;
758 case UNGT
: reverse_regs
= 1; invert
= 0; gen_fn
= gen_sunlt_sf
; break;
759 case UNLT
: reverse_regs
= 0; invert
= 0; gen_fn
= gen_sunlt_sf
; break;
760 case UNGE
: reverse_regs
= 1; invert
= 0; gen_fn
= gen_sunle_sf
; break;
762 reverse_regs
= 0; invert
= 0; gen_fn
= gen_sunordered_sf
; break;
764 reverse_regs
= 0; invert
= 1; gen_fn
= gen_sunordered_sf
; break;
766 fatal_insn ("bad test", gen_rtx_fmt_ee (test_code
, VOIDmode
, cmp0
, cmp1
));
767 reverse_regs
= 0; invert
= 0; gen_fn
= 0; /* avoid compiler warnings */
777 brtmp
= gen_rtx_REG (CCmode
, FPCC_REGNUM
);
778 emit_insn (gen_fn (brtmp
, cmp0
, cmp1
));
780 return gen_rtx_fmt_ee (invert
? EQ
: NE
, VOIDmode
, brtmp
, const0_rtx
);
785 xtensa_expand_conditional_branch (rtx
*operands
, enum machine_mode mode
)
787 enum rtx_code test_code
= GET_CODE (operands
[0]);
788 rtx cmp0
= operands
[1];
789 rtx cmp1
= operands
[2];
798 fatal_insn ("bad test", gen_rtx_fmt_ee (test_code
, VOIDmode
, cmp0
, cmp1
));
802 cmp
= gen_int_relational (test_code
, cmp0
, cmp1
, &invert
);
806 if (!TARGET_HARD_FLOAT
)
807 fatal_insn ("bad test", gen_rtx_fmt_ee (test_code
, VOIDmode
,
810 cmp
= gen_float_relational (test_code
, cmp0
, cmp1
);
814 /* Generate the branch. */
816 label1
= gen_rtx_LABEL_REF (VOIDmode
, operands
[3]);
825 emit_jump_insn (gen_rtx_SET (VOIDmode
, pc_rtx
,
826 gen_rtx_IF_THEN_ELSE (VOIDmode
, cmp
,
833 gen_conditional_move (enum rtx_code code
, enum machine_mode mode
,
840 /* Jump optimization calls get_condition() which canonicalizes
841 comparisons like (GE x <const>) to (GT x <const-1>).
842 Transform those comparisons back to GE, since that is the
843 comparison supported in Xtensa. We shouldn't have to
844 transform <LE x const> comparisons, because neither
845 xtensa_expand_conditional_branch() nor get_condition() will
848 if ((code
== GT
) && (op1
== constm1_rtx
))
853 cmp
= gen_rtx_fmt_ee (code
, VOIDmode
, cc0_rtx
, const0_rtx
);
855 if (boolean_operator (cmp
, VOIDmode
))
857 /* Swap the operands to make const0 second. */
858 if (op0
== const0_rtx
)
864 /* If not comparing against zero, emit a comparison (subtract). */
865 if (op1
!= const0_rtx
)
867 op0
= expand_binop (SImode
, sub_optab
, op0
, op1
,
868 0, 0, OPTAB_LIB_WIDEN
);
872 else if (branch_operator (cmp
, VOIDmode
))
874 /* Swap the operands to make const0 second. */
875 if (op0
== const0_rtx
)
882 case LT
: code
= GE
; break;
883 case GE
: code
= LT
; break;
884 default: gcc_unreachable ();
888 if (op1
!= const0_rtx
)
894 return gen_rtx_fmt_ee (code
, VOIDmode
, op0
, op1
);
897 if (TARGET_HARD_FLOAT
&& mode
== SFmode
)
898 return gen_float_relational (code
, op0
, op1
);
905 xtensa_expand_conditional_move (rtx
*operands
, int isflt
)
907 rtx dest
= operands
[0];
908 rtx cmp
= operands
[1];
909 enum machine_mode cmp_mode
= GET_MODE (XEXP (cmp
, 0));
910 rtx (*gen_fn
) (rtx
, rtx
, rtx
, rtx
, rtx
);
912 if (!(cmp
= gen_conditional_move (GET_CODE (cmp
), cmp_mode
,
913 XEXP (cmp
, 0), XEXP (cmp
, 1))))
917 gen_fn
= (cmp_mode
== SImode
918 ? gen_movsfcc_internal0
919 : gen_movsfcc_internal1
);
921 gen_fn
= (cmp_mode
== SImode
922 ? gen_movsicc_internal0
923 : gen_movsicc_internal1
);
925 emit_insn (gen_fn (dest
, XEXP (cmp
, 0), operands
[2], operands
[3], cmp
));
931 xtensa_expand_scc (rtx operands
[4], enum machine_mode cmp_mode
)
933 rtx dest
= operands
[0];
935 rtx one_tmp
, zero_tmp
;
936 rtx (*gen_fn
) (rtx
, rtx
, rtx
, rtx
, rtx
);
938 if (!(cmp
= gen_conditional_move (GET_CODE (operands
[1]), cmp_mode
,
939 operands
[2], operands
[3])))
942 one_tmp
= gen_reg_rtx (SImode
);
943 zero_tmp
= gen_reg_rtx (SImode
);
944 emit_insn (gen_movsi (one_tmp
, const_true_rtx
));
945 emit_insn (gen_movsi (zero_tmp
, const0_rtx
));
947 gen_fn
= (cmp_mode
== SImode
948 ? gen_movsicc_internal0
949 : gen_movsicc_internal1
);
950 emit_insn (gen_fn (dest
, XEXP (cmp
, 0), one_tmp
, zero_tmp
, cmp
));
955 /* Split OP[1] into OP[2,3] and likewise for OP[0] into OP[0,1]. MODE is
956 for the output, i.e., the input operands are twice as big as MODE. */
959 xtensa_split_operand_pair (rtx operands
[4], enum machine_mode mode
)
961 switch (GET_CODE (operands
[1]))
964 operands
[3] = gen_rtx_REG (mode
, REGNO (operands
[1]) + 1);
965 operands
[2] = gen_rtx_REG (mode
, REGNO (operands
[1]));
969 operands
[3] = adjust_address (operands
[1], mode
, GET_MODE_SIZE (mode
));
970 operands
[2] = adjust_address (operands
[1], mode
, 0);
975 split_double (operands
[1], &operands
[2], &operands
[3]);
982 switch (GET_CODE (operands
[0]))
985 operands
[1] = gen_rtx_REG (mode
, REGNO (operands
[0]) + 1);
986 operands
[0] = gen_rtx_REG (mode
, REGNO (operands
[0]));
990 operands
[1] = adjust_address (operands
[0], mode
, GET_MODE_SIZE (mode
));
991 operands
[0] = adjust_address (operands
[0], mode
, 0);
1000 /* Emit insns to move operands[1] into operands[0].
1001 Return 1 if we have written out everything that needs to be done to
1002 do the move. Otherwise, return 0 and the caller will emit the move
1006 xtensa_emit_move_sequence (rtx
*operands
, enum machine_mode mode
)
1008 rtx src
= operands
[1];
1010 if (CONSTANT_P (src
)
1011 && (GET_CODE (src
) != CONST_INT
|| ! xtensa_simm12b (INTVAL (src
))))
1013 rtx dst
= operands
[0];
1015 if (xtensa_tls_referenced_p (src
))
1019 if (GET_CODE (src
) == CONST
&& GET_CODE (XEXP (src
, 0)) == PLUS
)
1021 addend
= XEXP (XEXP (src
, 0), 1);
1022 src
= XEXP (XEXP (src
, 0), 0);
1025 src
= xtensa_legitimize_tls_address (src
);
1028 src
= gen_rtx_PLUS (mode
, src
, addend
);
1029 src
= force_operand (src
, dst
);
1031 emit_move_insn (dst
, src
);
1035 if (! TARGET_CONST16
)
1037 src
= force_const_mem (SImode
, src
);
1041 /* PC-relative loads are always SImode, and CONST16 is only
1042 supported in the movsi pattern, so add a SUBREG for any other
1047 if (register_operand (dst
, mode
))
1049 emit_move_insn (simplify_gen_subreg (SImode
, dst
, mode
, 0), src
);
1054 src
= force_reg (SImode
, src
);
1055 src
= gen_lowpart_SUBREG (mode
, src
);
1061 if (!(reload_in_progress
| reload_completed
)
1062 && !xtensa_valid_move (mode
, operands
))
1063 operands
[1] = force_reg (mode
, operands
[1]);
1065 operands
[1] = xtensa_copy_incoming_a7 (operands
[1]);
1067 /* During reload we don't want to emit (subreg:X (mem:Y)) since that
1068 instruction won't be recognized after reload, so we remove the
1069 subreg and adjust mem accordingly. */
1070 if (reload_in_progress
)
1072 operands
[0] = fixup_subreg_mem (operands
[0]);
1073 operands
[1] = fixup_subreg_mem (operands
[1]);
1080 fixup_subreg_mem (rtx x
)
1082 if (GET_CODE (x
) == SUBREG
1083 && GET_CODE (SUBREG_REG (x
)) == REG
1084 && REGNO (SUBREG_REG (x
)) >= FIRST_PSEUDO_REGISTER
)
1087 gen_rtx_SUBREG (GET_MODE (x
),
1088 reg_equiv_mem (REGNO (SUBREG_REG (x
))),
1090 x
= alter_subreg (&temp
, true);
1096 /* Check if an incoming argument in a7 is expected to be used soon and
1097 if OPND is a register or register pair that includes a7. If so,
1098 create a new pseudo and copy a7 into that pseudo at the very
1099 beginning of the function, followed by the special "set_frame_ptr"
1100 unspec_volatile insn. The return value is either the original
1101 operand, if it is not a7, or the new pseudo containing a copy of
1102 the incoming argument. This is necessary because the register
1103 allocator will ignore conflicts with a7 and may either assign some
1104 other pseudo to a7 or use a7 as the hard_frame_pointer, clobbering
1105 the incoming argument in a7. By copying the argument out of a7 as
1106 the very first thing, and then immediately following that with an
1107 unspec_volatile to keep the scheduler away, we should avoid any
1108 problems. Putting the set_frame_ptr insn at the beginning, with
1109 only the a7 copy before it, also makes it easier for the prologue
1110 expander to initialize the frame pointer after the a7 copy and to
1111 fix up the a7 copy to use the stack pointer instead of the frame
1115 xtensa_copy_incoming_a7 (rtx opnd
)
1117 rtx entry_insns
= 0;
1119 enum machine_mode mode
;
1121 if (!cfun
->machine
->need_a7_copy
)
1124 /* This function should never be called again once a7 has been copied. */
1125 gcc_assert (!cfun
->machine
->set_frame_ptr_insn
);
1127 mode
= GET_MODE (opnd
);
1129 /* The operand using a7 may come in a later instruction, so just return
1130 the original operand if it doesn't use a7. */
1132 if (GET_CODE (reg
) == SUBREG
)
1134 gcc_assert (SUBREG_BYTE (reg
) == 0);
1135 reg
= SUBREG_REG (reg
);
1137 if (GET_CODE (reg
) != REG
1138 || REGNO (reg
) > A7_REG
1139 || REGNO (reg
) + HARD_REGNO_NREGS (A7_REG
, mode
) <= A7_REG
)
1142 /* 1-word args will always be in a7; 2-word args in a6/a7. */
1143 gcc_assert (REGNO (reg
) + HARD_REGNO_NREGS (A7_REG
, mode
) - 1 == A7_REG
);
1145 cfun
->machine
->need_a7_copy
= false;
1147 /* Copy a7 to a new pseudo at the function entry. Use gen_raw_REG to
1148 create the REG for a7 so that hard_frame_pointer_rtx is not used. */
1151 tmp
= gen_reg_rtx (mode
);
1157 /* Copy the value out of A7 here but keep the first word in A6 until
1158 after the set_frame_ptr insn. Otherwise, the register allocator
1159 may decide to put "subreg (tmp, 0)" in A7 and clobber the incoming
1161 emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode
, tmp
, 4),
1162 gen_raw_REG (SImode
, A7_REG
)));
1165 emit_insn (gen_movsf_internal (tmp
, gen_raw_REG (mode
, A7_REG
)));
1168 emit_insn (gen_movsi_internal (tmp
, gen_raw_REG (mode
, A7_REG
)));
1171 emit_insn (gen_movhi_internal (tmp
, gen_raw_REG (mode
, A7_REG
)));
1174 emit_insn (gen_movqi_internal (tmp
, gen_raw_REG (mode
, A7_REG
)));
1180 cfun
->machine
->set_frame_ptr_insn
= emit_insn (gen_set_frame_ptr ());
1182 /* For DF and DI mode arguments, copy the incoming value in A6 now. */
1183 if (mode
== DFmode
|| mode
== DImode
)
1184 emit_insn (gen_movsi_internal (gen_rtx_SUBREG (SImode
, tmp
, 0),
1185 gen_rtx_REG (SImode
, A7_REG
- 1)));
1186 entry_insns
= get_insns ();
1189 if (cfun
->machine
->vararg_a7
)
1191 /* This is called from within builtin_saveregs, which will insert the
1192 saveregs code at the function entry, ahead of anything placed at
1193 the function entry now. Instead, save the sequence to be inserted
1194 at the beginning of the saveregs code. */
1195 cfun
->machine
->vararg_a7_copy
= entry_insns
;
1199 /* Put entry_insns after the NOTE that starts the function. If
1200 this is inside a start_sequence, make the outer-level insn
1201 chain current, so the code is placed at the start of the
1203 push_topmost_sequence ();
1204 /* Do not use entry_of_function() here. This is called from within
1205 expand_function_start, when the CFG still holds GIMPLE. */
1206 emit_insn_after (entry_insns
, get_insns ());
1207 pop_topmost_sequence ();
1214 /* Try to expand a block move operation to a sequence of RTL move
1215 instructions. If not optimizing, or if the block size is not a
1216 constant, or if the block is too large, the expansion fails and GCC
1217 falls back to calling memcpy().
1219 operands[0] is the destination
1220 operands[1] is the source
1221 operands[2] is the length
1222 operands[3] is the alignment */
1225 xtensa_expand_block_move (rtx
*operands
)
1227 static const enum machine_mode mode_from_align
[] =
1229 VOIDmode
, QImode
, HImode
, VOIDmode
, SImode
,
1232 rtx dst_mem
= operands
[0];
1233 rtx src_mem
= operands
[1];
1234 HOST_WIDE_INT bytes
, align
;
1235 int num_pieces
, move_ratio
;
1237 enum machine_mode mode
[2];
1246 /* If this is not a fixed size move, just call memcpy. */
1247 if (!optimize
|| (GET_CODE (operands
[2]) != CONST_INT
))
1250 bytes
= INTVAL (operands
[2]);
1251 align
= INTVAL (operands
[3]);
1253 /* Anything to move? */
1257 if (align
> MOVE_MAX
)
1260 /* Decide whether to expand inline based on the optimization level. */
1263 move_ratio
= LARGEST_MOVE_RATIO
;
1264 num_pieces
= (bytes
/ align
) + (bytes
% align
); /* Close enough anyway. */
1265 if (num_pieces
> move_ratio
)
1268 x
= XEXP (dst_mem
, 0);
1271 x
= force_reg (Pmode
, x
);
1272 dst_mem
= replace_equiv_address (dst_mem
, x
);
1275 x
= XEXP (src_mem
, 0);
1278 x
= force_reg (Pmode
, x
);
1279 src_mem
= replace_equiv_address (src_mem
, x
);
1282 active
[0] = active
[1] = false;
1293 next_amount
= (bytes
>= 4 ? 4 : (bytes
>= 2 ? 2 : 1));
1294 next_amount
= MIN (next_amount
, align
);
1296 amount
[next
] = next_amount
;
1297 mode
[next
] = mode_from_align
[next_amount
];
1298 temp
[next
] = gen_reg_rtx (mode
[next
]);
1300 x
= adjust_address (src_mem
, mode
[next
], offset_ld
);
1301 emit_insn (gen_rtx_SET (VOIDmode
, temp
[next
], x
));
1303 offset_ld
+= next_amount
;
1304 bytes
-= next_amount
;
1305 active
[next
] = true;
1310 active
[phase
] = false;
1312 x
= adjust_address (dst_mem
, mode
[phase
], offset_st
);
1313 emit_insn (gen_rtx_SET (VOIDmode
, x
, temp
[phase
]));
1315 offset_st
+= amount
[phase
];
1318 while (active
[next
]);
1325 xtensa_expand_nonlocal_goto (rtx
*operands
)
1327 rtx goto_handler
= operands
[1];
1328 rtx containing_fp
= operands
[3];
1330 /* Generate a call to "__xtensa_nonlocal_goto" (in libgcc); the code
1331 is too big to generate in-line. */
1333 if (GET_CODE (containing_fp
) != REG
)
1334 containing_fp
= force_reg (Pmode
, containing_fp
);
1336 emit_library_call (gen_rtx_SYMBOL_REF (Pmode
, "__xtensa_nonlocal_goto"),
1337 LCT_NORMAL
, VOIDmode
, 2,
1338 containing_fp
, Pmode
,
1339 goto_handler
, Pmode
);
1343 static struct machine_function
*
1344 xtensa_init_machine_status (void)
1346 return ggc_alloc_cleared_machine_function ();
1350 /* Shift VAL of mode MODE left by COUNT bits. */
1353 xtensa_expand_mask_and_shift (rtx val
, enum machine_mode mode
, rtx count
)
1355 val
= expand_simple_binop (SImode
, AND
, val
, GEN_INT (GET_MODE_MASK (mode
)),
1356 NULL_RTX
, 1, OPTAB_DIRECT
);
1357 return expand_simple_binop (SImode
, ASHIFT
, val
, count
,
1358 NULL_RTX
, 1, OPTAB_DIRECT
);
1362 /* Structure to hold the initial parameters for a compare_and_swap operation
1363 in HImode and QImode. */
1365 struct alignment_context
1367 rtx memsi
; /* SI aligned memory location. */
1368 rtx shift
; /* Bit offset with regard to lsb. */
1369 rtx modemask
; /* Mask of the HQImode shifted by SHIFT bits. */
1370 rtx modemaski
; /* ~modemask */
1374 /* Initialize structure AC for word access to HI and QI mode memory. */
1377 init_alignment_context (struct alignment_context
*ac
, rtx mem
)
1379 enum machine_mode mode
= GET_MODE (mem
);
1380 rtx byteoffset
= NULL_RTX
;
1381 bool aligned
= (MEM_ALIGN (mem
) >= GET_MODE_BITSIZE (SImode
));
1384 ac
->memsi
= adjust_address (mem
, SImode
, 0); /* Memory is aligned. */
1387 /* Alignment is unknown. */
1390 /* Force the address into a register. */
1391 addr
= force_reg (Pmode
, XEXP (mem
, 0));
1393 /* Align it to SImode. */
1394 align
= expand_simple_binop (Pmode
, AND
, addr
,
1395 GEN_INT (-GET_MODE_SIZE (SImode
)),
1396 NULL_RTX
, 1, OPTAB_DIRECT
);
1398 ac
->memsi
= gen_rtx_MEM (SImode
, align
);
1399 MEM_VOLATILE_P (ac
->memsi
) = MEM_VOLATILE_P (mem
);
1400 set_mem_alias_set (ac
->memsi
, ALIAS_SET_MEMORY_BARRIER
);
1401 set_mem_align (ac
->memsi
, GET_MODE_BITSIZE (SImode
));
1403 byteoffset
= expand_simple_binop (Pmode
, AND
, addr
,
1404 GEN_INT (GET_MODE_SIZE (SImode
) - 1),
1405 NULL_RTX
, 1, OPTAB_DIRECT
);
1408 /* Calculate shiftcount. */
1409 if (TARGET_BIG_ENDIAN
)
1411 ac
->shift
= GEN_INT (GET_MODE_SIZE (SImode
) - GET_MODE_SIZE (mode
));
1413 ac
->shift
= expand_simple_binop (SImode
, MINUS
, ac
->shift
, byteoffset
,
1414 NULL_RTX
, 1, OPTAB_DIRECT
);
1419 ac
->shift
= NULL_RTX
;
1421 ac
->shift
= byteoffset
;
1424 if (ac
->shift
!= NULL_RTX
)
1426 /* Shift is the byte count, but we need the bitcount. */
1427 ac
->shift
= expand_simple_binop (SImode
, MULT
, ac
->shift
,
1428 GEN_INT (BITS_PER_UNIT
),
1429 NULL_RTX
, 1, OPTAB_DIRECT
);
1430 ac
->modemask
= expand_simple_binop (SImode
, ASHIFT
,
1431 GEN_INT (GET_MODE_MASK (mode
)),
1433 NULL_RTX
, 1, OPTAB_DIRECT
);
1436 ac
->modemask
= GEN_INT (GET_MODE_MASK (mode
));
1438 ac
->modemaski
= expand_simple_unop (SImode
, NOT
, ac
->modemask
, NULL_RTX
, 1);
1442 /* Expand an atomic compare and swap operation for HImode and QImode.
1443 MEM is the memory location, CMP the old value to compare MEM with
1444 and NEW_RTX the value to set if CMP == MEM. */
1447 xtensa_expand_compare_and_swap (rtx target
, rtx mem
, rtx cmp
, rtx new_rtx
)
1449 enum machine_mode mode
= GET_MODE (mem
);
1450 struct alignment_context ac
;
1451 rtx tmp
, cmpv
, newv
, val
;
1452 rtx oldval
= gen_reg_rtx (SImode
);
1453 rtx res
= gen_reg_rtx (SImode
);
1454 rtx csloop
= gen_label_rtx ();
1455 rtx csend
= gen_label_rtx ();
1457 init_alignment_context (&ac
, mem
);
1459 if (ac
.shift
!= NULL_RTX
)
1461 cmp
= xtensa_expand_mask_and_shift (cmp
, mode
, ac
.shift
);
1462 new_rtx
= xtensa_expand_mask_and_shift (new_rtx
, mode
, ac
.shift
);
1465 /* Load the surrounding word into VAL with the MEM value masked out. */
1466 val
= force_reg (SImode
, expand_simple_binop (SImode
, AND
, ac
.memsi
,
1467 ac
.modemaski
, NULL_RTX
, 1,
1469 emit_label (csloop
);
1471 /* Patch CMP and NEW_RTX into VAL at correct position. */
1472 cmpv
= force_reg (SImode
, expand_simple_binop (SImode
, IOR
, cmp
, val
,
1473 NULL_RTX
, 1, OPTAB_DIRECT
));
1474 newv
= force_reg (SImode
, expand_simple_binop (SImode
, IOR
, new_rtx
, val
,
1475 NULL_RTX
, 1, OPTAB_DIRECT
));
1477 /* Jump to end if we're done. */
1478 emit_insn (gen_sync_compare_and_swapsi (res
, ac
.memsi
, cmpv
, newv
));
1479 emit_cmp_and_jump_insns (res
, cmpv
, EQ
, const0_rtx
, SImode
, true, csend
);
1481 /* Check for changes outside mode. */
1482 emit_move_insn (oldval
, val
);
1483 tmp
= expand_simple_binop (SImode
, AND
, res
, ac
.modemaski
,
1484 val
, 1, OPTAB_DIRECT
);
1486 emit_move_insn (val
, tmp
);
1488 /* Loop internal if so. */
1489 emit_cmp_and_jump_insns (oldval
, val
, NE
, const0_rtx
, SImode
, true, csloop
);
1493 /* Return the correct part of the bitfield. */
1494 convert_move (target
,
1495 (ac
.shift
== NULL_RTX
? res
1496 : expand_simple_binop (SImode
, LSHIFTRT
, res
, ac
.shift
,
1497 NULL_RTX
, 1, OPTAB_DIRECT
)),
1502 /* Expand an atomic operation CODE of mode MODE (either HImode or QImode --
1503 the default expansion works fine for SImode). MEM is the memory location
1504 and VAL the value to play with. If AFTER is true then store the value
1505 MEM holds after the operation, if AFTER is false then store the value MEM
1506 holds before the operation. If TARGET is zero then discard that value, else
1507 store it to TARGET. */
1510 xtensa_expand_atomic (enum rtx_code code
, rtx target
, rtx mem
, rtx val
,
1513 enum machine_mode mode
= GET_MODE (mem
);
1514 struct alignment_context ac
;
1515 rtx csloop
= gen_label_rtx ();
1517 rtx old
= gen_reg_rtx (SImode
);
1518 rtx new_rtx
= gen_reg_rtx (SImode
);
1519 rtx orig
= NULL_RTX
;
1521 init_alignment_context (&ac
, mem
);
1523 /* Prepare values before the compare-and-swap loop. */
1524 if (ac
.shift
!= NULL_RTX
)
1525 val
= xtensa_expand_mask_and_shift (val
, mode
, ac
.shift
);
1530 orig
= gen_reg_rtx (SImode
);
1531 convert_move (orig
, val
, 1);
1539 case MULT
: /* NAND */
1541 /* val = "11..1<val>11..1" */
1542 val
= expand_simple_binop (SImode
, XOR
, val
, ac
.modemaski
,
1543 NULL_RTX
, 1, OPTAB_DIRECT
);
1550 /* Load full word. Subsequent loads are performed by S32C1I. */
1551 cmp
= force_reg (SImode
, ac
.memsi
);
1553 emit_label (csloop
);
1554 emit_move_insn (old
, cmp
);
1560 val
= expand_simple_binop (SImode
, code
, old
, orig
,
1561 NULL_RTX
, 1, OPTAB_DIRECT
);
1562 val
= expand_simple_binop (SImode
, AND
, val
, ac
.modemask
,
1563 NULL_RTX
, 1, OPTAB_DIRECT
);
1566 tmp
= expand_simple_binop (SImode
, AND
, old
, ac
.modemaski
,
1567 NULL_RTX
, 1, OPTAB_DIRECT
);
1568 tmp
= expand_simple_binop (SImode
, IOR
, tmp
, val
,
1569 new_rtx
, 1, OPTAB_DIRECT
);
1575 tmp
= expand_simple_binop (SImode
, code
, old
, val
,
1576 new_rtx
, 1, OPTAB_DIRECT
);
1579 case MULT
: /* NAND */
1580 tmp
= expand_simple_binop (SImode
, XOR
, old
, ac
.modemask
,
1581 NULL_RTX
, 1, OPTAB_DIRECT
);
1582 tmp
= expand_simple_binop (SImode
, AND
, tmp
, val
,
1583 new_rtx
, 1, OPTAB_DIRECT
);
1591 emit_move_insn (new_rtx
, tmp
);
1592 emit_insn (gen_sync_compare_and_swapsi (cmp
, ac
.memsi
, old
, new_rtx
));
1593 emit_cmp_and_jump_insns (cmp
, old
, NE
, const0_rtx
, SImode
, true, csloop
);
1597 tmp
= (after
? new_rtx
: cmp
);
1598 convert_move (target
,
1599 (ac
.shift
== NULL_RTX
? tmp
1600 : expand_simple_binop (SImode
, LSHIFTRT
, tmp
, ac
.shift
,
1601 NULL_RTX
, 1, OPTAB_DIRECT
)),
1608 xtensa_setup_frame_addresses (void)
1610 /* Set flag to cause TARGET_FRAME_POINTER_REQUIRED to return true. */
1611 cfun
->machine
->accesses_prev_frame
= 1;
1614 (gen_rtx_SYMBOL_REF (Pmode
, "__xtensa_libgcc_window_spill"),
1615 LCT_NORMAL
, VOIDmode
, 0);
1619 /* Emit the assembly for the end of a zero-cost loop. Normally we just emit
1620 a comment showing where the end of the loop is. However, if there is a
1621 label or a branch at the end of the loop then we need to place a nop
1622 there. If the loop ends with a label we need the nop so that branches
1623 targeting that label will target the nop (and thus remain in the loop),
1624 instead of targeting the instruction after the loop (and thus exiting
1625 the loop). If the loop ends with a branch, we need the nop in case the
1626 branch is targeting a location inside the loop. When the branch
1627 executes it will cause the loop count to be decremented even if it is
1628 taken (because it is the last instruction in the loop), so we need to
1629 nop after the branch to prevent the loop count from being decremented
1630 when the branch is taken. */
1633 xtensa_emit_loop_end (rtx insn
, rtx
*operands
)
1637 for (insn
= PREV_INSN (insn
); insn
&& !done
; insn
= PREV_INSN (insn
))
1639 switch (GET_CODE (insn
))
1646 output_asm_insn (TARGET_DENSITY
? "nop.n" : "nop", operands
);
1652 rtx body
= PATTERN (insn
);
1654 if (GET_CODE (body
) == JUMP_INSN
)
1656 output_asm_insn (TARGET_DENSITY
? "nop.n" : "nop", operands
);
1659 else if ((GET_CODE (body
) != USE
)
1660 && (GET_CODE (body
) != CLOBBER
))
1667 output_asm_insn ("# loop end for %0", operands
);
1672 xtensa_emit_branch (bool inverted
, bool immed
, rtx
*operands
)
1674 static char result
[64];
1678 code
= GET_CODE (operands
[3]);
1681 case EQ
: op
= inverted
? "ne" : "eq"; break;
1682 case NE
: op
= inverted
? "eq" : "ne"; break;
1683 case LT
: op
= inverted
? "ge" : "lt"; break;
1684 case GE
: op
= inverted
? "lt" : "ge"; break;
1685 case LTU
: op
= inverted
? "geu" : "ltu"; break;
1686 case GEU
: op
= inverted
? "ltu" : "geu"; break;
1687 default: gcc_unreachable ();
1692 if (INTVAL (operands
[1]) == 0)
1693 sprintf (result
, "b%sz%s\t%%0, %%2", op
,
1694 (TARGET_DENSITY
&& (code
== EQ
|| code
== NE
)) ? ".n" : "");
1696 sprintf (result
, "b%si\t%%0, %%d1, %%2", op
);
1699 sprintf (result
, "b%s\t%%0, %%1, %%2", op
);
1706 xtensa_emit_bit_branch (bool inverted
, bool immed
, rtx
*operands
)
1708 static char result
[64];
1711 switch (GET_CODE (operands
[3]))
1713 case EQ
: op
= inverted
? "bs" : "bc"; break;
1714 case NE
: op
= inverted
? "bc" : "bs"; break;
1715 default: gcc_unreachable ();
1720 unsigned bitnum
= INTVAL (operands
[1]) & 0x1f;
1721 operands
[1] = GEN_INT (bitnum
);
1722 sprintf (result
, "b%si\t%%0, %%d1, %%2", op
);
1725 sprintf (result
, "b%s\t%%0, %%1, %%2", op
);
1732 xtensa_emit_movcc (bool inverted
, bool isfp
, bool isbool
, rtx
*operands
)
1734 static char result
[64];
1738 code
= GET_CODE (operands
[4]);
1743 case EQ
: op
= inverted
? "t" : "f"; break;
1744 case NE
: op
= inverted
? "f" : "t"; break;
1745 default: gcc_unreachable ();
1752 case EQ
: op
= inverted
? "nez" : "eqz"; break;
1753 case NE
: op
= inverted
? "eqz" : "nez"; break;
1754 case LT
: op
= inverted
? "gez" : "ltz"; break;
1755 case GE
: op
= inverted
? "ltz" : "gez"; break;
1756 default: gcc_unreachable ();
1760 sprintf (result
, "mov%s%s\t%%0, %%%d, %%1",
1761 op
, isfp
? ".s" : "", inverted
? 3 : 2);
1767 xtensa_emit_call (int callop
, rtx
*operands
)
1769 static char result
[64];
1770 rtx tgt
= operands
[callop
];
1772 if (GET_CODE (tgt
) == CONST_INT
)
1773 sprintf (result
, "call8\t0x%lx", INTVAL (tgt
));
1774 else if (register_operand (tgt
, VOIDmode
))
1775 sprintf (result
, "callx8\t%%%d", callop
);
1777 sprintf (result
, "call8\t%%%d", callop
);
1784 xtensa_legitimate_address_p (enum machine_mode mode
, rtx addr
, bool strict
)
1786 /* Allow constant pool addresses. */
1787 if (mode
!= BLKmode
&& GET_MODE_SIZE (mode
) >= UNITS_PER_WORD
1788 && ! TARGET_CONST16
&& constantpool_address_p (addr
)
1789 && ! xtensa_tls_referenced_p (addr
))
1792 while (GET_CODE (addr
) == SUBREG
)
1793 addr
= SUBREG_REG (addr
);
1795 /* Allow base registers. */
1796 if (GET_CODE (addr
) == REG
&& BASE_REG_P (addr
, strict
))
1799 /* Check for "register + offset" addressing. */
1800 if (GET_CODE (addr
) == PLUS
)
1802 rtx xplus0
= XEXP (addr
, 0);
1803 rtx xplus1
= XEXP (addr
, 1);
1804 enum rtx_code code0
;
1805 enum rtx_code code1
;
1807 while (GET_CODE (xplus0
) == SUBREG
)
1808 xplus0
= SUBREG_REG (xplus0
);
1809 code0
= GET_CODE (xplus0
);
1811 while (GET_CODE (xplus1
) == SUBREG
)
1812 xplus1
= SUBREG_REG (xplus1
);
1813 code1
= GET_CODE (xplus1
);
1815 /* Swap operands if necessary so the register is first. */
1816 if (code0
!= REG
&& code1
== REG
)
1818 xplus0
= XEXP (addr
, 1);
1819 xplus1
= XEXP (addr
, 0);
1820 code0
= GET_CODE (xplus0
);
1821 code1
= GET_CODE (xplus1
);
1824 if (code0
== REG
&& BASE_REG_P (xplus0
, strict
)
1825 && code1
== CONST_INT
1826 && xtensa_mem_offset (INTVAL (xplus1
), mode
))
1834 /* Construct the SYMBOL_REF for the _TLS_MODULE_BASE_ symbol. */
1836 static GTY(()) rtx xtensa_tls_module_base_symbol
;
1839 xtensa_tls_module_base (void)
1841 if (! xtensa_tls_module_base_symbol
)
1843 xtensa_tls_module_base_symbol
=
1844 gen_rtx_SYMBOL_REF (Pmode
, "_TLS_MODULE_BASE_");
1845 SYMBOL_REF_FLAGS (xtensa_tls_module_base_symbol
)
1846 |= TLS_MODEL_GLOBAL_DYNAMIC
<< SYMBOL_FLAG_TLS_SHIFT
;
1849 return xtensa_tls_module_base_symbol
;
1854 xtensa_call_tls_desc (rtx sym
, rtx
*retp
)
1856 rtx fn
, arg
, a10
, call_insn
, insns
;
1859 fn
= gen_reg_rtx (Pmode
);
1860 arg
= gen_reg_rtx (Pmode
);
1861 a10
= gen_rtx_REG (Pmode
, 10);
1863 emit_insn (gen_tls_func (fn
, sym
));
1864 emit_insn (gen_tls_arg (arg
, sym
));
1865 emit_move_insn (a10
, arg
);
1866 call_insn
= emit_call_insn (gen_tls_call (a10
, fn
, sym
, const1_rtx
));
1867 use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn
), a10
);
1868 insns
= get_insns ();
1877 xtensa_legitimize_tls_address (rtx x
)
1879 unsigned int model
= SYMBOL_REF_TLS_MODEL (x
);
1880 rtx dest
, tp
, ret
, modbase
, base
, addend
, insns
;
1882 dest
= gen_reg_rtx (Pmode
);
1885 case TLS_MODEL_GLOBAL_DYNAMIC
:
1886 insns
= xtensa_call_tls_desc (x
, &ret
);
1887 emit_libcall_block (insns
, dest
, ret
, x
);
1890 case TLS_MODEL_LOCAL_DYNAMIC
:
1891 base
= gen_reg_rtx (Pmode
);
1892 modbase
= xtensa_tls_module_base ();
1893 insns
= xtensa_call_tls_desc (modbase
, &ret
);
1894 emit_libcall_block (insns
, base
, ret
, modbase
);
1895 addend
= force_reg (SImode
, gen_sym_DTPOFF (x
));
1896 emit_insn (gen_addsi3 (dest
, base
, addend
));
1899 case TLS_MODEL_INITIAL_EXEC
:
1900 case TLS_MODEL_LOCAL_EXEC
:
1901 tp
= gen_reg_rtx (SImode
);
1902 emit_insn (gen_get_thread_pointersi (tp
));
1903 addend
= force_reg (SImode
, gen_sym_TPOFF (x
));
1904 emit_insn (gen_addsi3 (dest
, tp
, addend
));
1916 xtensa_legitimize_address (rtx x
,
1917 rtx oldx ATTRIBUTE_UNUSED
,
1918 enum machine_mode mode
)
1920 if (xtensa_tls_symbol_p (x
))
1921 return xtensa_legitimize_tls_address (x
);
1923 if (GET_CODE (x
) == PLUS
)
1925 rtx plus0
= XEXP (x
, 0);
1926 rtx plus1
= XEXP (x
, 1);
1928 if (GET_CODE (plus0
) != REG
&& GET_CODE (plus1
) == REG
)
1930 plus0
= XEXP (x
, 1);
1931 plus1
= XEXP (x
, 0);
1934 /* Try to split up the offset to use an ADDMI instruction. */
1935 if (GET_CODE (plus0
) == REG
1936 && GET_CODE (plus1
) == CONST_INT
1937 && !xtensa_mem_offset (INTVAL (plus1
), mode
)
1938 && !xtensa_simm8 (INTVAL (plus1
))
1939 && xtensa_mem_offset (INTVAL (plus1
) & 0xff, mode
)
1940 && xtensa_simm8x256 (INTVAL (plus1
) & ~0xff))
1942 rtx temp
= gen_reg_rtx (Pmode
);
1943 rtx addmi_offset
= GEN_INT (INTVAL (plus1
) & ~0xff);
1944 emit_insn (gen_rtx_SET (Pmode
, temp
,
1945 gen_rtx_PLUS (Pmode
, plus0
, addmi_offset
)));
1946 return gen_rtx_PLUS (Pmode
, temp
, GEN_INT (INTVAL (plus1
) & 0xff));
1953 /* Worker function for TARGET_MODE_DEPENDENT_ADDRESS_P.
1955 Treat constant-pool references as "mode dependent" since they can
1956 only be accessed with SImode loads. This works around a bug in the
1957 combiner where a constant pool reference is temporarily converted
1958 to an HImode load, which is then assumed to zero-extend based on
1959 our definition of LOAD_EXTEND_OP. This is wrong because the high
1960 bits of a 16-bit value in the constant pool are now sign-extended
1964 xtensa_mode_dependent_address_p (const_rtx addr
,
1965 addr_space_t as ATTRIBUTE_UNUSED
)
1967 return constantpool_address_p (addr
);
1970 /* Helper for xtensa_tls_referenced_p. */
1973 xtensa_tls_referenced_p_1 (rtx
*x
, void *data ATTRIBUTE_UNUSED
)
1975 if (GET_CODE (*x
) == SYMBOL_REF
)
1976 return SYMBOL_REF_TLS_MODEL (*x
) != 0;
1978 /* Ignore TLS references that have already been legitimized. */
1979 if (GET_CODE (*x
) == UNSPEC
)
1981 switch (XINT (*x
, 1))
1985 case UNSPEC_TLS_FUNC
:
1986 case UNSPEC_TLS_ARG
:
1987 case UNSPEC_TLS_CALL
:
1998 /* Return TRUE if X contains any TLS symbol references. */
2001 xtensa_tls_referenced_p (rtx x
)
2003 if (! TARGET_HAVE_TLS
)
2006 return for_each_rtx (&x
, xtensa_tls_referenced_p_1
, NULL
);
2010 /* Implement TARGET_CANNOT_FORCE_CONST_MEM. */
2013 xtensa_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED
, rtx x
)
2015 return xtensa_tls_referenced_p (x
);
2019 /* Return the debugger register number to use for 'regno'. */
2022 xtensa_dbx_register_number (int regno
)
2026 if (GP_REG_P (regno
))
2028 regno
-= GP_REG_FIRST
;
2031 else if (BR_REG_P (regno
))
2033 regno
-= BR_REG_FIRST
;
2036 else if (FP_REG_P (regno
))
2038 regno
-= FP_REG_FIRST
;
2041 else if (ACC_REG_P (regno
))
2043 first
= 0x200; /* Start of Xtensa special registers. */
2044 regno
= 16; /* ACCLO is special register 16. */
2047 /* When optimizing, we sometimes get asked about pseudo-registers
2048 that don't represent hard registers. Return 0 for these. */
2052 return first
+ regno
;
2056 /* Argument support functions. */
2058 /* Initialize CUMULATIVE_ARGS for a function. */
2061 init_cumulative_args (CUMULATIVE_ARGS
*cum
, int incoming
)
2064 cum
->incoming
= incoming
;
2068 /* Advance the argument to the next argument position. */
2071 xtensa_function_arg_advance (cumulative_args_t cum
, enum machine_mode mode
,
2072 const_tree type
, bool named ATTRIBUTE_UNUSED
)
2077 arg_words
= &get_cumulative_args (cum
)->arg_words
;
2078 max
= MAX_ARGS_IN_REGISTERS
;
2080 words
= (((mode
!= BLKmode
)
2081 ? (int) GET_MODE_SIZE (mode
)
2082 : int_size_in_bytes (type
)) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
2084 if (*arg_words
< max
2085 && (targetm
.calls
.must_pass_in_stack (mode
, type
)
2086 || *arg_words
+ words
> max
))
2089 *arg_words
+= words
;
2093 /* Return an RTL expression containing the register for the given mode,
2094 or 0 if the argument is to be passed on the stack. INCOMING_P is nonzero
2095 if this is an incoming argument to the current function. */
2098 xtensa_function_arg_1 (cumulative_args_t cum_v
, enum machine_mode mode
,
2099 const_tree type
, bool incoming_p
)
2101 CUMULATIVE_ARGS
*cum
= get_cumulative_args (cum_v
);
2102 int regbase
, words
, max
;
2106 arg_words
= &cum
->arg_words
;
2107 regbase
= (incoming_p
? GP_ARG_FIRST
: GP_OUTGOING_ARG_FIRST
);
2108 max
= MAX_ARGS_IN_REGISTERS
;
2110 words
= (((mode
!= BLKmode
)
2111 ? (int) GET_MODE_SIZE (mode
)
2112 : int_size_in_bytes (type
)) + UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
2114 if (type
&& (TYPE_ALIGN (type
) > BITS_PER_WORD
))
2116 int align
= MIN (TYPE_ALIGN (type
), STACK_BOUNDARY
) / BITS_PER_WORD
;
2117 *arg_words
= (*arg_words
+ align
- 1) & -align
;
2120 if (*arg_words
+ words
> max
)
2123 regno
= regbase
+ *arg_words
;
2125 if (cum
->incoming
&& regno
<= A7_REG
&& regno
+ words
> A7_REG
)
2126 cfun
->machine
->need_a7_copy
= true;
2128 return gen_rtx_REG (mode
, regno
);
2131 /* Implement TARGET_FUNCTION_ARG. */
2134 xtensa_function_arg (cumulative_args_t cum
, enum machine_mode mode
,
2135 const_tree type
, bool named ATTRIBUTE_UNUSED
)
2137 return xtensa_function_arg_1 (cum
, mode
, type
, false);
2140 /* Implement TARGET_FUNCTION_INCOMING_ARG. */
2143 xtensa_function_incoming_arg (cumulative_args_t cum
, enum machine_mode mode
,
2144 const_tree type
, bool named ATTRIBUTE_UNUSED
)
2146 return xtensa_function_arg_1 (cum
, mode
, type
, true);
2150 xtensa_function_arg_boundary (enum machine_mode mode
, const_tree type
)
2152 unsigned int alignment
;
2154 alignment
= type
? TYPE_ALIGN (type
) : GET_MODE_ALIGNMENT (mode
);
2155 if (alignment
< PARM_BOUNDARY
)
2156 alignment
= PARM_BOUNDARY
;
2157 if (alignment
> STACK_BOUNDARY
)
2158 alignment
= STACK_BOUNDARY
;
2164 xtensa_return_in_msb (const_tree valtype
)
2166 return (TARGET_BIG_ENDIAN
2167 && AGGREGATE_TYPE_P (valtype
)
2168 && int_size_in_bytes (valtype
) >= UNITS_PER_WORD
);
2173 xtensa_option_override (void)
2176 enum machine_mode mode
;
2178 if (!TARGET_BOOLEANS
&& TARGET_HARD_FLOAT
)
2179 error ("boolean registers required for the floating-point option");
2181 /* Set up array giving whether a given register can hold a given mode. */
2182 for (mode
= VOIDmode
;
2183 mode
!= MAX_MACHINE_MODE
;
2184 mode
= (enum machine_mode
) ((int) mode
+ 1))
2186 int size
= GET_MODE_SIZE (mode
);
2187 enum mode_class mclass
= GET_MODE_CLASS (mode
);
2189 for (regno
= 0; regno
< FIRST_PSEUDO_REGISTER
; regno
++)
2193 if (ACC_REG_P (regno
))
2194 temp
= (TARGET_MAC16
2195 && (mclass
== MODE_INT
) && (size
<= UNITS_PER_WORD
));
2196 else if (GP_REG_P (regno
))
2197 temp
= ((regno
& 1) == 0 || (size
<= UNITS_PER_WORD
));
2198 else if (FP_REG_P (regno
))
2199 temp
= (TARGET_HARD_FLOAT
&& (mode
== SFmode
));
2200 else if (BR_REG_P (regno
))
2201 temp
= (TARGET_BOOLEANS
&& (mode
== CCmode
));
2205 xtensa_hard_regno_mode_ok
[(int) mode
][regno
] = temp
;
2209 init_machine_status
= xtensa_init_machine_status
;
2211 /* Check PIC settings. PIC is only supported when using L32R
2212 instructions, and some targets need to always use PIC. */
2213 if (flag_pic
&& TARGET_CONST16
)
2214 error ("-f%s is not supported with CONST16 instructions",
2215 (flag_pic
> 1 ? "PIC" : "pic"));
2216 else if (TARGET_FORCE_NO_PIC
)
2218 else if (XTENSA_ALWAYS_PIC
)
2221 error ("PIC is required but not supported with CONST16 instructions");
2224 /* There's no need for -fPIC (as opposed to -fpic) on Xtensa. */
2227 if (flag_pic
&& !flag_pie
)
2230 /* Hot/cold partitioning does not work on this architecture, because of
2231 constant pools (the load instruction cannot necessarily reach that far).
2232 Therefore disable it on this architecture. */
2233 if (flag_reorder_blocks_and_partition
)
2235 flag_reorder_blocks_and_partition
= 0;
2236 flag_reorder_blocks
= 1;
2240 /* A C compound statement to output to stdio stream STREAM the
2241 assembler syntax for an instruction operand X. X is an RTL
2244 CODE is a value that can be used to specify one of several ways
2245 of printing the operand. It is used when identical operands
2246 must be printed differently depending on the context. CODE
2247 comes from the '%' specification that was used to request
2248 printing of the operand. If the specification was just '%DIGIT'
2249 then CODE is 0; if the specification was '%LTR DIGIT' then CODE
2250 is the ASCII code for LTR.
2252 If X is a register, this macro should print the register's name.
2253 The names can be found in an array 'reg_names' whose type is
2254 'char *[]'. 'reg_names' is initialized from 'REGISTER_NAMES'.
2256 When the machine description has a specification '%PUNCT' (a '%'
2257 followed by a punctuation character), this macro is called with
2258 a null pointer for X and the punctuation character for CODE.
2260 'a', 'c', 'l', and 'n' are reserved.
2262 The Xtensa specific codes are:
2264 'd' CONST_INT, print as signed decimal
2265 'x' CONST_INT, print as signed hexadecimal
2266 'K' CONST_INT, print number of bits in mask for EXTUI
2267 'R' CONST_INT, print (X & 0x1f)
2268 'L' CONST_INT, print ((32 - X) & 0x1f)
2269 'D' REG, print second register of double-word register operand
2270 'N' MEM, print address of next word following a memory operand
2271 'v' MEM, if memory reference is volatile, output a MEMW before it
2272 't' any constant, add "@h" suffix for top 16 bits
2273 'b' any constant, add "@l" suffix for bottom 16 bits
2277 printx (FILE *file
, signed int val
)
2279 /* Print a hexadecimal value in a nice way. */
2280 if ((val
> -0xa) && (val
< 0xa))
2281 fprintf (file
, "%d", val
);
2283 fprintf (file
, "-0x%x", -val
);
2285 fprintf (file
, "0x%x", val
);
2290 print_operand (FILE *file
, rtx x
, int letter
)
2293 error ("PRINT_OPERAND null pointer");
2298 if (GET_CODE (x
) == REG
|| GET_CODE (x
) == SUBREG
)
2299 fprintf (file
, "%s", reg_names
[xt_true_regnum (x
) + 1]);
2301 output_operand_lossage ("invalid %%D value");
2305 if (GET_CODE (x
) == MEM
)
2307 /* For a volatile memory reference, emit a MEMW before the
2309 if (MEM_VOLATILE_P (x
) && TARGET_SERIALIZE_VOLATILE
)
2310 fprintf (file
, "memw\n\t");
2313 output_operand_lossage ("invalid %%v value");
2317 if (GET_CODE (x
) == MEM
2318 && (GET_MODE (x
) == DFmode
|| GET_MODE (x
) == DImode
))
2320 x
= adjust_address (x
, GET_MODE (x
) == DFmode
? SFmode
: SImode
, 4);
2321 output_address (XEXP (x
, 0));
2324 output_operand_lossage ("invalid %%N value");
2328 if (GET_CODE (x
) == CONST_INT
)
2331 unsigned val
= INTVAL (x
);
2337 if ((val
!= 0) || (num_bits
== 0) || (num_bits
> 16))
2338 fatal_insn ("invalid mask", x
);
2340 fprintf (file
, "%d", num_bits
);
2343 output_operand_lossage ("invalid %%K value");
2347 if (GET_CODE (x
) == CONST_INT
)
2348 fprintf (file
, "%ld", (32 - INTVAL (x
)) & 0x1f);
2350 output_operand_lossage ("invalid %%L value");
2354 if (GET_CODE (x
) == CONST_INT
)
2355 fprintf (file
, "%ld", INTVAL (x
) & 0x1f);
2357 output_operand_lossage ("invalid %%R value");
2361 if (GET_CODE (x
) == CONST_INT
)
2362 printx (file
, INTVAL (x
));
2364 output_operand_lossage ("invalid %%x value");
2368 if (GET_CODE (x
) == CONST_INT
)
2369 fprintf (file
, "%ld", INTVAL (x
));
2371 output_operand_lossage ("invalid %%d value");
2376 if (GET_CODE (x
) == CONST_INT
)
2378 printx (file
, INTVAL (x
));
2379 fputs (letter
== 't' ? "@h" : "@l", file
);
2381 else if (GET_CODE (x
) == CONST_DOUBLE
)
2384 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
2385 if (GET_MODE (x
) == SFmode
)
2388 REAL_VALUE_TO_TARGET_SINGLE (r
, l
);
2389 fprintf (file
, "0x%08lx@%c", l
, letter
== 't' ? 'h' : 'l');
2392 output_operand_lossage ("invalid %%t/%%b value");
2394 else if (GET_CODE (x
) == CONST
)
2396 /* X must be a symbolic constant on ELF. Write an expression
2397 suitable for 'const16' that sets the high or low 16 bits. */
2398 if (GET_CODE (XEXP (x
, 0)) != PLUS
2399 || (GET_CODE (XEXP (XEXP (x
, 0), 0)) != SYMBOL_REF
2400 && GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
2401 || GET_CODE (XEXP (XEXP (x
, 0), 1)) != CONST_INT
)
2402 output_operand_lossage ("invalid %%t/%%b value");
2403 print_operand (file
, XEXP (XEXP (x
, 0), 0), 0);
2404 fputs (letter
== 't' ? "@h" : "@l", file
);
2405 /* There must be a non-alphanumeric character between 'h' or 'l'
2406 and the number. The '-' is added by print_operand() already. */
2407 if (INTVAL (XEXP (XEXP (x
, 0), 1)) >= 0)
2409 print_operand (file
, XEXP (XEXP (x
, 0), 1), 0);
2413 output_addr_const (file
, x
);
2414 fputs (letter
== 't' ? "@h" : "@l", file
);
2419 if (GET_CODE (x
) == REG
|| GET_CODE (x
) == SUBREG
)
2420 fprintf (file
, "%s", reg_names
[xt_true_regnum (x
)]);
2421 else if (GET_CODE (x
) == MEM
)
2422 output_address (XEXP (x
, 0));
2423 else if (GET_CODE (x
) == CONST_INT
)
2424 fprintf (file
, "%ld", INTVAL (x
));
2426 output_addr_const (file
, x
);
2431 /* A C compound statement to output to stdio stream STREAM the
2432 assembler syntax for an instruction operand that is a memory
2433 reference whose address is ADDR. ADDR is an RTL expression. */
2436 print_operand_address (FILE *file
, rtx addr
)
2439 error ("PRINT_OPERAND_ADDRESS, null pointer");
2441 switch (GET_CODE (addr
))
2444 fatal_insn ("invalid address", addr
);
2448 fprintf (file
, "%s, 0", reg_names
[REGNO (addr
)]);
2454 rtx offset
= (rtx
)0;
2455 rtx arg0
= XEXP (addr
, 0);
2456 rtx arg1
= XEXP (addr
, 1);
2458 if (GET_CODE (arg0
) == REG
)
2463 else if (GET_CODE (arg1
) == REG
)
2469 fatal_insn ("no register in address", addr
);
2471 if (CONSTANT_P (offset
))
2473 fprintf (file
, "%s, ", reg_names
[REGNO (reg
)]);
2474 output_addr_const (file
, offset
);
2477 fatal_insn ("address offset not a constant", addr
);
2485 output_addr_const (file
, addr
);
2490 /* Implement TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA. */
2493 xtensa_output_addr_const_extra (FILE *fp
, rtx x
)
2495 if (GET_CODE (x
) == UNSPEC
&& XVECLEN (x
, 0) == 1)
2497 switch (XINT (x
, 1))
2500 output_addr_const (fp
, XVECEXP (x
, 0, 0));
2501 fputs ("@TPOFF", fp
);
2504 output_addr_const (fp
, XVECEXP (x
, 0, 0));
2505 fputs ("@DTPOFF", fp
);
2510 output_addr_const (fp
, XVECEXP (x
, 0, 0));
2524 xtensa_output_literal (FILE *file
, rtx x
, enum machine_mode mode
, int labelno
)
2531 fprintf (file
, "\t.literal .LC%u, ", (unsigned) labelno
);
2533 switch (GET_MODE_CLASS (mode
))
2536 gcc_assert (GET_CODE (x
) == CONST_DOUBLE
);
2538 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
2542 REAL_VALUE_TO_TARGET_SINGLE (r
, value_long
[0]);
2543 if (HOST_BITS_PER_LONG
> 32)
2544 value_long
[0] &= 0xffffffff;
2545 fprintf (file
, "0x%08lx\n", value_long
[0]);
2549 REAL_VALUE_TO_TARGET_DOUBLE (r
, value_long
);
2550 if (HOST_BITS_PER_LONG
> 32)
2552 value_long
[0] &= 0xffffffff;
2553 value_long
[1] &= 0xffffffff;
2555 fprintf (file
, "0x%08lx, 0x%08lx\n",
2556 value_long
[0], value_long
[1]);
2566 case MODE_PARTIAL_INT
:
2567 size
= GET_MODE_SIZE (mode
);
2571 output_addr_const (file
, x
);
2576 split_double (x
, &first
, &second
);
2577 output_addr_const (file
, first
);
2579 output_addr_const (file
, second
);
2594 /* Return the bytes needed to compute the frame pointer from the current
2597 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
2598 #define XTENSA_STACK_ALIGN(LOC) (((LOC) + STACK_BYTES-1) & ~(STACK_BYTES-1))
2601 compute_frame_size (int size
)
2603 /* Add space for the incoming static chain value. */
2604 if (cfun
->static_chain_decl
!= NULL
)
2605 size
+= (1 * UNITS_PER_WORD
);
2607 xtensa_current_frame_size
=
2608 XTENSA_STACK_ALIGN (size
2609 + crtl
->outgoing_args_size
2610 + (WINDOW_SIZE
* UNITS_PER_WORD
));
2611 return xtensa_current_frame_size
;
2616 xtensa_frame_pointer_required (void)
2618 /* The code to expand builtin_frame_addr and builtin_return_addr
2619 currently uses the hard_frame_pointer instead of frame_pointer.
2620 This seems wrong but maybe it's necessary for other architectures.
2621 This function is derived from the i386 code. */
2623 if (cfun
->machine
->accesses_prev_frame
)
2630 /* minimum frame = reg save area (4 words) plus static chain (1 word)
2631 and the total number of words must be a multiple of 128 bits. */
2632 #define MIN_FRAME_SIZE (8 * UNITS_PER_WORD)
2635 xtensa_expand_prologue (void)
2637 HOST_WIDE_INT total_size
;
2641 total_size
= compute_frame_size (get_frame_size ());
2642 size_rtx
= GEN_INT (total_size
);
2644 if (total_size
< (1 << (12+3)))
2645 insn
= emit_insn (gen_entry (size_rtx
));
2648 /* Use a8 as a temporary since a0-a7 may be live. */
2649 rtx tmp_reg
= gen_rtx_REG (Pmode
, A8_REG
);
2650 emit_insn (gen_entry (GEN_INT (MIN_FRAME_SIZE
)));
2651 emit_move_insn (tmp_reg
, GEN_INT (total_size
- MIN_FRAME_SIZE
));
2652 emit_insn (gen_subsi3 (tmp_reg
, stack_pointer_rtx
, tmp_reg
));
2653 insn
= emit_insn (gen_movsi (stack_pointer_rtx
, tmp_reg
));
2656 if (frame_pointer_needed
)
2658 if (cfun
->machine
->set_frame_ptr_insn
)
2662 push_topmost_sequence ();
2663 first
= get_insns ();
2664 pop_topmost_sequence ();
2666 /* For all instructions prior to set_frame_ptr_insn, replace
2667 hard_frame_pointer references with stack_pointer. */
2669 insn
!= cfun
->machine
->set_frame_ptr_insn
;
2670 insn
= NEXT_INSN (insn
))
2674 PATTERN (insn
) = replace_rtx (copy_rtx (PATTERN (insn
)),
2675 hard_frame_pointer_rtx
,
2677 df_insn_rescan (insn
);
2682 insn
= emit_insn (gen_movsi (hard_frame_pointer_rtx
,
2683 stack_pointer_rtx
));
2686 /* Create a note to describe the CFA. Because this is only used to set
2687 DW_AT_frame_base for debug info, don't bother tracking changes through
2688 each instruction in the prologue. It just takes up space. */
2689 note_rtx
= gen_rtx_SET (VOIDmode
, (frame_pointer_needed
2690 ? hard_frame_pointer_rtx
2691 : stack_pointer_rtx
),
2692 plus_constant (Pmode
, stack_pointer_rtx
,
2694 RTX_FRAME_RELATED_P (insn
) = 1;
2695 add_reg_note (insn
, REG_FRAME_RELATED_EXPR
, note_rtx
);
2699 /* Clear variables at function end. */
2702 xtensa_function_epilogue (FILE *file ATTRIBUTE_UNUSED
,
2703 HOST_WIDE_INT size ATTRIBUTE_UNUSED
)
2705 xtensa_current_frame_size
= 0;
2710 xtensa_return_addr (int count
, rtx frame
)
2712 rtx result
, retaddr
, curaddr
, label
;
2715 retaddr
= gen_rtx_REG (Pmode
, A0_REG
);
2718 rtx addr
= plus_constant (Pmode
, frame
, -4 * UNITS_PER_WORD
);
2719 addr
= memory_address (Pmode
, addr
);
2720 retaddr
= gen_reg_rtx (Pmode
);
2721 emit_move_insn (retaddr
, gen_rtx_MEM (Pmode
, addr
));
2724 /* The 2 most-significant bits of the return address on Xtensa hold
2725 the register window size. To get the real return address, these
2726 bits must be replaced with the high bits from some address in the
2729 /* Get the 2 high bits of a local label in the code. */
2730 curaddr
= gen_reg_rtx (Pmode
);
2731 label
= gen_label_rtx ();
2733 LABEL_PRESERVE_P (label
) = 1;
2734 emit_move_insn (curaddr
, gen_rtx_LABEL_REF (Pmode
, label
));
2735 emit_insn (gen_lshrsi3 (curaddr
, curaddr
, GEN_INT (30)));
2736 emit_insn (gen_ashlsi3 (curaddr
, curaddr
, GEN_INT (30)));
2738 /* Clear the 2 high bits of the return address. */
2739 result
= gen_reg_rtx (Pmode
);
2740 emit_insn (gen_ashlsi3 (result
, retaddr
, GEN_INT (2)));
2741 emit_insn (gen_lshrsi3 (result
, result
, GEN_INT (2)));
2743 /* Combine them to get the result. */
2744 emit_insn (gen_iorsi3 (result
, result
, curaddr
));
2748 /* Disable the use of word-sized or smaller complex modes for structures,
2749 and for function arguments in particular, where they cause problems with
2750 register a7. The xtensa_copy_incoming_a7 function assumes that there is
2751 a single reference to an argument in a7, but with small complex modes the
2752 real and imaginary components may be extracted separately, leading to two
2753 uses of the register, only one of which would be replaced. */
2756 xtensa_member_type_forces_blk (const_tree
, enum machine_mode mode
)
2758 return mode
== CQImode
|| mode
== CHImode
;
2761 /* Create the va_list data type.
2763 This structure is set up by __builtin_saveregs. The __va_reg field
2764 points to a stack-allocated region holding the contents of the
2765 incoming argument registers. The __va_ndx field is an index
2766 initialized to the position of the first unnamed (variable)
2767 argument. This same index is also used to address the arguments
2768 passed in memory. Thus, the __va_stk field is initialized to point
2769 to the position of the first argument in memory offset to account
2770 for the arguments passed in registers and to account for the size
2771 of the argument registers not being 16-byte aligned. E.G., there
2772 are 6 argument registers of 4 bytes each, but we want the __va_ndx
2773 for the first stack argument to have the maximal alignment of 16
2774 bytes, so we offset the __va_stk address by 32 bytes so that
2775 __va_stk[32] references the first argument on the stack. */
2778 xtensa_build_builtin_va_list (void)
2780 tree f_stk
, f_reg
, f_ndx
, record
, type_decl
;
2782 record
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
2783 type_decl
= build_decl (BUILTINS_LOCATION
,
2784 TYPE_DECL
, get_identifier ("__va_list_tag"), record
);
2786 f_stk
= build_decl (BUILTINS_LOCATION
,
2787 FIELD_DECL
, get_identifier ("__va_stk"),
2789 f_reg
= build_decl (BUILTINS_LOCATION
,
2790 FIELD_DECL
, get_identifier ("__va_reg"),
2792 f_ndx
= build_decl (BUILTINS_LOCATION
,
2793 FIELD_DECL
, get_identifier ("__va_ndx"),
2796 DECL_FIELD_CONTEXT (f_stk
) = record
;
2797 DECL_FIELD_CONTEXT (f_reg
) = record
;
2798 DECL_FIELD_CONTEXT (f_ndx
) = record
;
2800 TYPE_STUB_DECL (record
) = type_decl
;
2801 TYPE_NAME (record
) = type_decl
;
2802 TYPE_FIELDS (record
) = f_stk
;
2803 DECL_CHAIN (f_stk
) = f_reg
;
2804 DECL_CHAIN (f_reg
) = f_ndx
;
2806 layout_type (record
);
2811 /* Save the incoming argument registers on the stack. Returns the
2812 address of the saved registers. */
2815 xtensa_builtin_saveregs (void)
2818 int arg_words
= crtl
->args
.info
.arg_words
;
2819 int gp_left
= MAX_ARGS_IN_REGISTERS
- arg_words
;
2824 /* Allocate the general-purpose register space. */
2825 gp_regs
= assign_stack_local
2826 (BLKmode
, MAX_ARGS_IN_REGISTERS
* UNITS_PER_WORD
, -1);
2827 set_mem_alias_set (gp_regs
, get_varargs_alias_set ());
2829 /* Now store the incoming registers. */
2830 cfun
->machine
->need_a7_copy
= true;
2831 cfun
->machine
->vararg_a7
= true;
2832 move_block_from_reg (GP_ARG_FIRST
+ arg_words
,
2833 adjust_address (gp_regs
, BLKmode
,
2834 arg_words
* UNITS_PER_WORD
),
2836 gcc_assert (cfun
->machine
->vararg_a7_copy
!= 0);
2837 emit_insn_before (cfun
->machine
->vararg_a7_copy
, get_insns ());
2839 return XEXP (gp_regs
, 0);
2843 /* Implement `va_start' for varargs and stdarg. We look at the
2844 current function to fill in an initial va_list. */
2847 xtensa_va_start (tree valist
, rtx nextarg ATTRIBUTE_UNUSED
)
2855 arg_words
= crtl
->args
.info
.arg_words
;
2857 f_stk
= TYPE_FIELDS (va_list_type_node
);
2858 f_reg
= DECL_CHAIN (f_stk
);
2859 f_ndx
= DECL_CHAIN (f_reg
);
2861 stk
= build3 (COMPONENT_REF
, TREE_TYPE (f_stk
), valist
, f_stk
, NULL_TREE
);
2862 reg
= build3 (COMPONENT_REF
, TREE_TYPE (f_reg
), unshare_expr (valist
),
2864 ndx
= build3 (COMPONENT_REF
, TREE_TYPE (f_ndx
), unshare_expr (valist
),
2867 /* Call __builtin_saveregs; save the result in __va_reg */
2868 u
= make_tree (sizetype
, expand_builtin_saveregs ());
2869 u
= fold_convert (ptr_type_node
, u
);
2870 t
= build2 (MODIFY_EXPR
, ptr_type_node
, reg
, u
);
2871 TREE_SIDE_EFFECTS (t
) = 1;
2872 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2874 /* Set the __va_stk member to ($arg_ptr - 32). */
2875 u
= make_tree (ptr_type_node
, virtual_incoming_args_rtx
);
2876 u
= fold_build_pointer_plus_hwi (u
, -32);
2877 t
= build2 (MODIFY_EXPR
, ptr_type_node
, stk
, u
);
2878 TREE_SIDE_EFFECTS (t
) = 1;
2879 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2881 /* Set the __va_ndx member. If the first variable argument is on
2882 the stack, adjust __va_ndx by 2 words to account for the extra
2883 alignment offset for __va_stk. */
2884 if (arg_words
>= MAX_ARGS_IN_REGISTERS
)
2886 t
= build2 (MODIFY_EXPR
, integer_type_node
, ndx
,
2887 build_int_cst (integer_type_node
, arg_words
* UNITS_PER_WORD
));
2888 TREE_SIDE_EFFECTS (t
) = 1;
2889 expand_expr (t
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2893 /* Implement `va_arg'. */
2896 xtensa_gimplify_va_arg_expr (tree valist
, tree type
, gimple_seq
*pre_p
,
2897 gimple_seq
*post_p ATTRIBUTE_UNUSED
)
2902 tree type_size
, array
, orig_ndx
, addr
, size
, va_size
, t
;
2903 tree lab_false
, lab_over
, lab_false2
;
2906 indirect
= pass_by_reference (NULL
, TYPE_MODE (type
), type
, false);
2908 type
= build_pointer_type (type
);
2910 /* Handle complex values as separate real and imaginary parts. */
2911 if (TREE_CODE (type
) == COMPLEX_TYPE
)
2913 tree real_part
, imag_part
;
2915 real_part
= xtensa_gimplify_va_arg_expr (valist
, TREE_TYPE (type
),
2917 real_part
= get_initialized_tmp_var (real_part
, pre_p
, NULL
);
2919 imag_part
= xtensa_gimplify_va_arg_expr (unshare_expr (valist
),
2922 imag_part
= get_initialized_tmp_var (imag_part
, pre_p
, NULL
);
2924 return build2 (COMPLEX_EXPR
, type
, real_part
, imag_part
);
2927 f_stk
= TYPE_FIELDS (va_list_type_node
);
2928 f_reg
= DECL_CHAIN (f_stk
);
2929 f_ndx
= DECL_CHAIN (f_reg
);
2931 stk
= build3 (COMPONENT_REF
, TREE_TYPE (f_stk
), valist
,
2933 reg
= build3 (COMPONENT_REF
, TREE_TYPE (f_reg
), unshare_expr (valist
),
2935 ndx
= build3 (COMPONENT_REF
, TREE_TYPE (f_ndx
), unshare_expr (valist
),
2938 type_size
= size_in_bytes (type
);
2939 va_size
= round_up (type_size
, UNITS_PER_WORD
);
2940 gimplify_expr (&va_size
, pre_p
, NULL
, is_gimple_val
, fb_rvalue
);
2943 /* First align __va_ndx if necessary for this arg:
2945 orig_ndx = (AP).__va_ndx;
2946 if (__alignof__ (TYPE) > 4 )
2947 orig_ndx = ((orig_ndx + __alignof__ (TYPE) - 1)
2948 & -__alignof__ (TYPE)); */
2950 orig_ndx
= get_initialized_tmp_var (ndx
, pre_p
, NULL
);
2952 if (TYPE_ALIGN (type
) > BITS_PER_WORD
)
2954 int align
= MIN (TYPE_ALIGN (type
), STACK_BOUNDARY
) / BITS_PER_UNIT
;
2956 t
= build2 (PLUS_EXPR
, integer_type_node
, unshare_expr (orig_ndx
),
2957 build_int_cst (integer_type_node
, align
- 1));
2958 t
= build2 (BIT_AND_EXPR
, integer_type_node
, t
,
2959 build_int_cst (integer_type_node
, -align
));
2960 gimplify_assign (unshare_expr (orig_ndx
), t
, pre_p
);
2964 /* Increment __va_ndx to point past the argument:
2966 (AP).__va_ndx = orig_ndx + __va_size (TYPE); */
2968 t
= fold_convert (integer_type_node
, va_size
);
2969 t
= build2 (PLUS_EXPR
, integer_type_node
, orig_ndx
, t
);
2970 gimplify_assign (unshare_expr (ndx
), t
, pre_p
);
2973 /* Check if the argument is in registers:
2975 if ((AP).__va_ndx <= __MAX_ARGS_IN_REGISTERS * 4
2976 && !must_pass_in_stack (type))
2977 __array = (AP).__va_reg; */
2979 array
= create_tmp_var (ptr_type_node
, NULL
);
2982 if (!targetm
.calls
.must_pass_in_stack (TYPE_MODE (type
), type
))
2984 lab_false
= create_artificial_label (UNKNOWN_LOCATION
);
2985 lab_over
= create_artificial_label (UNKNOWN_LOCATION
);
2987 t
= build2 (GT_EXPR
, boolean_type_node
, unshare_expr (ndx
),
2988 build_int_cst (integer_type_node
,
2989 MAX_ARGS_IN_REGISTERS
* UNITS_PER_WORD
));
2990 t
= build3 (COND_EXPR
, void_type_node
, t
,
2991 build1 (GOTO_EXPR
, void_type_node
, lab_false
),
2993 gimplify_and_add (t
, pre_p
);
2995 gimplify_assign (unshare_expr (array
), reg
, pre_p
);
2997 t
= build1 (GOTO_EXPR
, void_type_node
, lab_over
);
2998 gimplify_and_add (t
, pre_p
);
3000 t
= build1 (LABEL_EXPR
, void_type_node
, lab_false
);
3001 gimplify_and_add (t
, pre_p
);
3005 /* ...otherwise, the argument is on the stack (never split between
3006 registers and the stack -- change __va_ndx if necessary):
3010 if (orig_ndx <= __MAX_ARGS_IN_REGISTERS * 4)
3011 (AP).__va_ndx = 32 + __va_size (TYPE);
3012 __array = (AP).__va_stk;
3015 lab_false2
= create_artificial_label (UNKNOWN_LOCATION
);
3017 t
= build2 (GT_EXPR
, boolean_type_node
, unshare_expr (orig_ndx
),
3018 build_int_cst (integer_type_node
,
3019 MAX_ARGS_IN_REGISTERS
* UNITS_PER_WORD
));
3020 t
= build3 (COND_EXPR
, void_type_node
, t
,
3021 build1 (GOTO_EXPR
, void_type_node
, lab_false2
),
3023 gimplify_and_add (t
, pre_p
);
3025 t
= size_binop (PLUS_EXPR
, unshare_expr (va_size
), size_int (32));
3026 t
= fold_convert (integer_type_node
, t
);
3027 gimplify_assign (unshare_expr (ndx
), t
, pre_p
);
3029 t
= build1 (LABEL_EXPR
, void_type_node
, lab_false2
);
3030 gimplify_and_add (t
, pre_p
);
3032 gimplify_assign (array
, stk
, pre_p
);
3036 t
= build1 (LABEL_EXPR
, void_type_node
, lab_over
);
3037 gimplify_and_add (t
, pre_p
);
3041 /* Given the base array pointer (__array) and index to the subsequent
3042 argument (__va_ndx), find the address:
3044 __array + (AP).__va_ndx - (BYTES_BIG_ENDIAN && sizeof (TYPE) < 4
3048 The results are endian-dependent because values smaller than one word
3049 are aligned differently. */
3052 if (BYTES_BIG_ENDIAN
&& TREE_CODE (type_size
) == INTEGER_CST
)
3054 t
= fold_build2 (GE_EXPR
, boolean_type_node
, unshare_expr (type_size
),
3055 size_int (PARM_BOUNDARY
/ BITS_PER_UNIT
));
3056 t
= fold_build3 (COND_EXPR
, sizetype
, t
, unshare_expr (va_size
),
3057 unshare_expr (type_size
));
3061 size
= unshare_expr (va_size
);
3063 t
= fold_convert (sizetype
, unshare_expr (ndx
));
3064 t
= build2 (MINUS_EXPR
, sizetype
, t
, size
);
3065 addr
= fold_build_pointer_plus (unshare_expr (array
), t
);
3067 addr
= fold_convert (build_pointer_type (type
), addr
);
3069 addr
= build_va_arg_indirect_ref (addr
);
3070 return build_va_arg_indirect_ref (addr
);
3078 XTENSA_BUILTIN_UMULSIDI3
,
3084 xtensa_init_builtins (void)
3088 ftype
= build_function_type_list (unsigned_intDI_type_node
,
3089 unsigned_intSI_type_node
,
3090 unsigned_intSI_type_node
, NULL_TREE
);
3092 decl
= add_builtin_function ("__builtin_umulsidi3", ftype
,
3093 XTENSA_BUILTIN_UMULSIDI3
, BUILT_IN_MD
,
3094 "__umulsidi3", NULL_TREE
);
3095 TREE_NOTHROW (decl
) = 1;
3096 TREE_READONLY (decl
) = 1;
3101 xtensa_fold_builtin (tree fndecl
, int n_args ATTRIBUTE_UNUSED
, tree
*args
,
3102 bool ignore ATTRIBUTE_UNUSED
)
3104 unsigned int fcode
= DECL_FUNCTION_CODE (fndecl
);
3109 case XTENSA_BUILTIN_UMULSIDI3
:
3112 if ((TREE_CODE (arg0
) == INTEGER_CST
&& TREE_CODE (arg1
) == INTEGER_CST
)
3113 || TARGET_MUL32_HIGH
)
3114 return fold_build2 (MULT_EXPR
, unsigned_intDI_type_node
,
3115 fold_convert (unsigned_intDI_type_node
, arg0
),
3116 fold_convert (unsigned_intDI_type_node
, arg1
));
3120 internal_error ("bad builtin code");
3129 xtensa_expand_builtin (tree exp
, rtx target
,
3130 rtx subtarget ATTRIBUTE_UNUSED
,
3131 enum machine_mode mode ATTRIBUTE_UNUSED
,
3134 tree fndecl
= TREE_OPERAND (CALL_EXPR_FN (exp
), 0);
3135 unsigned int fcode
= DECL_FUNCTION_CODE (fndecl
);
3139 case XTENSA_BUILTIN_UMULSIDI3
:
3140 /* The umulsidi3 builtin is just a mechanism to avoid calling the real
3141 __umulsidi3 function when the Xtensa configuration can directly
3142 implement it. If not, just call the function. */
3143 return expand_call (exp
, target
, ignore
);
3146 internal_error ("bad builtin code");
3151 /* Worker function for TARGET_PREFERRED_RELOAD_CLASS. */
3154 xtensa_preferred_reload_class (rtx x
, reg_class_t rclass
)
3156 if (CONSTANT_P (x
) && CONST_DOUBLE_P (x
))
3159 /* Don't use the stack pointer or hard frame pointer for reloads!
3160 The hard frame pointer would normally be OK except that it may
3161 briefly hold an incoming argument in the prologue, and reload
3162 won't know that it is live because the hard frame pointer is
3163 treated specially. */
3165 if (rclass
== AR_REGS
|| rclass
== GR_REGS
)
3171 /* Worker function for TARGET_PREFERRED_OUTPUT_RELOAD_CLASS. */
3174 xtensa_preferred_output_reload_class (rtx x ATTRIBUTE_UNUSED
,
3177 /* Don't use the stack pointer or hard frame pointer for reloads!
3178 The hard frame pointer would normally be OK except that it may
3179 briefly hold an incoming argument in the prologue, and reload
3180 won't know that it is live because the hard frame pointer is
3181 treated specially. */
3183 if (rclass
== AR_REGS
|| rclass
== GR_REGS
)
3189 /* Worker function for TARGET_SECONDARY_RELOAD. */
3192 xtensa_secondary_reload (bool in_p
, rtx x
, reg_class_t rclass
,
3193 enum machine_mode mode
, secondary_reload_info
*sri
)
3197 if (in_p
&& constantpool_mem_p (x
))
3199 if (rclass
== FP_REGS
)
3203 sri
->icode
= CODE_FOR_reloadqi_literal
;
3204 else if (mode
== HImode
)
3205 sri
->icode
= CODE_FOR_reloadhi_literal
;
3208 regno
= xt_true_regnum (x
);
3209 if (ACC_REG_P (regno
))
3210 return ((rclass
== GR_REGS
|| rclass
== RL_REGS
) ? NO_REGS
: RL_REGS
);
3211 if (rclass
== ACC_REG
)
3212 return (GP_REG_P (regno
) ? NO_REGS
: RL_REGS
);
3219 order_regs_for_local_alloc (void)
3221 if (!leaf_function_p ())
3223 memcpy (reg_alloc_order
, reg_nonleaf_alloc_order
,
3224 FIRST_PSEUDO_REGISTER
* sizeof (int));
3228 int i
, num_arg_regs
;
3231 /* Use the AR registers in increasing order (skipping a0 and a1)
3232 but save the incoming argument registers for a last resort. */
3233 num_arg_regs
= crtl
->args
.info
.arg_words
;
3234 if (num_arg_regs
> MAX_ARGS_IN_REGISTERS
)
3235 num_arg_regs
= MAX_ARGS_IN_REGISTERS
;
3236 for (i
= GP_ARG_FIRST
; i
< 16 - num_arg_regs
; i
++)
3237 reg_alloc_order
[nxt
++] = i
+ num_arg_regs
;
3238 for (i
= 0; i
< num_arg_regs
; i
++)
3239 reg_alloc_order
[nxt
++] = GP_ARG_FIRST
+ i
;
3241 /* List the coprocessor registers in order. */
3242 for (i
= 0; i
< BR_REG_NUM
; i
++)
3243 reg_alloc_order
[nxt
++] = BR_REG_FIRST
+ i
;
3245 /* List the FP registers in order for now. */
3246 for (i
= 0; i
< 16; i
++)
3247 reg_alloc_order
[nxt
++] = FP_REG_FIRST
+ i
;
3249 /* GCC requires that we list *all* the registers.... */
3250 reg_alloc_order
[nxt
++] = 0; /* a0 = return address */
3251 reg_alloc_order
[nxt
++] = 1; /* a1 = stack pointer */
3252 reg_alloc_order
[nxt
++] = 16; /* pseudo frame pointer */
3253 reg_alloc_order
[nxt
++] = 17; /* pseudo arg pointer */
3255 reg_alloc_order
[nxt
++] = ACC_REG_FIRST
; /* MAC16 accumulator */
3260 /* Some Xtensa targets support multiple bss sections. If the section
3261 name ends with ".bss", add SECTION_BSS to the flags. */
3264 xtensa_multibss_section_type_flags (tree decl
, const char *name
, int reloc
)
3266 unsigned int flags
= default_section_type_flags (decl
, name
, reloc
);
3269 suffix
= strrchr (name
, '.');
3270 if (suffix
&& strcmp (suffix
, ".bss") == 0)
3272 if (!decl
|| (TREE_CODE (decl
) == VAR_DECL
3273 && DECL_INITIAL (decl
) == NULL_TREE
))
3274 flags
|= SECTION_BSS
; /* @nobits */
3276 warning (0, "only uninitialized variables can be placed in a "
3284 /* The literal pool stays with the function. */
3287 xtensa_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED
,
3288 rtx x ATTRIBUTE_UNUSED
,
3289 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
3291 return function_section (current_function_decl
);
3294 /* Worker function for TARGET_REGISTER_MOVE_COST. */
3297 xtensa_register_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED
,
3298 reg_class_t from
, reg_class_t to
)
3300 if (from
== to
&& from
!= BR_REGS
&& to
!= BR_REGS
)
3302 else if (reg_class_subset_p (from
, AR_REGS
)
3303 && reg_class_subset_p (to
, AR_REGS
))
3305 else if (reg_class_subset_p (from
, AR_REGS
) && to
== ACC_REG
)
3307 else if (from
== ACC_REG
&& reg_class_subset_p (to
, AR_REGS
))
3313 /* Worker function for TARGET_MEMORY_MOVE_COST. */
3316 xtensa_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED
,
3317 reg_class_t rclass ATTRIBUTE_UNUSED
,
3318 bool in ATTRIBUTE_UNUSED
)
3323 /* Compute a (partial) cost for rtx X. Return true if the complete
3324 cost has been computed, and false if subexpressions should be
3325 scanned. In either case, *TOTAL contains the cost result. */
3328 xtensa_rtx_costs (rtx x
, int code
, int outer_code
, int opno ATTRIBUTE_UNUSED
,
3329 int *total
, bool speed ATTRIBUTE_UNUSED
)
3337 if (xtensa_simm12b (INTVAL (x
)))
3344 if (xtensa_simm8 (INTVAL (x
))
3345 || xtensa_simm8x256 (INTVAL (x
)))
3352 if (xtensa_mask_immediate (INTVAL (x
)))
3359 if ((INTVAL (x
) == 0) || xtensa_b4const (INTVAL (x
)))
3370 /* No way to tell if X is the 2nd operand so be conservative. */
3373 if (xtensa_simm12b (INTVAL (x
)))
3375 else if (TARGET_CONST16
)
3376 *total
= COSTS_N_INSNS (2);
3385 *total
= COSTS_N_INSNS (2);
3392 *total
= COSTS_N_INSNS (4);
3400 (GET_MODE_SIZE (GET_MODE (x
)) > UNITS_PER_WORD
) ? 2 : 1;
3402 if (memory_address_p (GET_MODE (x
), XEXP ((x
), 0)))
3403 *total
= COSTS_N_INSNS (num_words
);
3405 *total
= COSTS_N_INSNS (2*num_words
);
3411 *total
= COSTS_N_INSNS (TARGET_NSA
? 5 : 50);
3415 *total
= COSTS_N_INSNS (TARGET_NSA
? 1 : 50);
3419 *total
= COSTS_N_INSNS ((GET_MODE (x
) == DImode
) ? 3 : 2);
3425 if (GET_MODE (x
) == DImode
)
3426 *total
= COSTS_N_INSNS (2);
3428 *total
= COSTS_N_INSNS (1);
3434 if (GET_MODE (x
) == DImode
)
3435 *total
= COSTS_N_INSNS (50);
3437 *total
= COSTS_N_INSNS (1);
3442 enum machine_mode xmode
= GET_MODE (x
);
3443 if (xmode
== SFmode
)
3444 *total
= COSTS_N_INSNS (TARGET_HARD_FLOAT
? 1 : 50);
3445 else if (xmode
== DFmode
)
3446 *total
= COSTS_N_INSNS (50);
3448 *total
= COSTS_N_INSNS (4);
3455 enum machine_mode xmode
= GET_MODE (x
);
3456 if (xmode
== SFmode
)
3457 *total
= COSTS_N_INSNS (TARGET_HARD_FLOAT
? 1 : 50);
3458 else if (xmode
== DFmode
|| xmode
== DImode
)
3459 *total
= COSTS_N_INSNS (50);
3461 *total
= COSTS_N_INSNS (1);
3466 *total
= COSTS_N_INSNS ((GET_MODE (x
) == DImode
) ? 4 : 2);
3471 enum machine_mode xmode
= GET_MODE (x
);
3472 if (xmode
== SFmode
)
3473 *total
= COSTS_N_INSNS (TARGET_HARD_FLOAT
? 4 : 50);
3474 else if (xmode
== DFmode
)
3475 *total
= COSTS_N_INSNS (50);
3476 else if (xmode
== DImode
)
3477 *total
= COSTS_N_INSNS (TARGET_MUL32_HIGH
? 10 : 50);
3478 else if (TARGET_MUL32
)
3479 *total
= COSTS_N_INSNS (4);
3480 else if (TARGET_MAC16
)
3481 *total
= COSTS_N_INSNS (16);
3482 else if (TARGET_MUL16
)
3483 *total
= COSTS_N_INSNS (12);
3485 *total
= COSTS_N_INSNS (50);
3492 enum machine_mode xmode
= GET_MODE (x
);
3493 if (xmode
== SFmode
)
3495 *total
= COSTS_N_INSNS (TARGET_HARD_FLOAT_DIV
? 8 : 50);
3498 else if (xmode
== DFmode
)
3500 *total
= COSTS_N_INSNS (50);
3509 enum machine_mode xmode
= GET_MODE (x
);
3510 if (xmode
== DImode
)
3511 *total
= COSTS_N_INSNS (50);
3512 else if (TARGET_DIV32
)
3513 *total
= COSTS_N_INSNS (32);
3515 *total
= COSTS_N_INSNS (50);
3520 if (GET_MODE (x
) == SFmode
)
3521 *total
= COSTS_N_INSNS (TARGET_HARD_FLOAT_SQRT
? 8 : 50);
3523 *total
= COSTS_N_INSNS (50);
3530 *total
= COSTS_N_INSNS (TARGET_MINMAX
? 1 : 50);
3535 *total
= COSTS_N_INSNS (TARGET_SEXT
? 1 : 2);
3540 *total
= COSTS_N_INSNS (1);
3548 /* Worker function for TARGET_RETURN_IN_MEMORY. */
3551 xtensa_return_in_memory (const_tree type
, const_tree fntype ATTRIBUTE_UNUSED
)
3553 return ((unsigned HOST_WIDE_INT
) int_size_in_bytes (type
)
3554 > 4 * UNITS_PER_WORD
);
3557 /* Worker function for TARGET_FUNCTION_VALUE. */
3560 xtensa_function_value (const_tree valtype
, const_tree func ATTRIBUTE_UNUSED
,
3563 return gen_rtx_REG ((INTEGRAL_TYPE_P (valtype
)
3564 && TYPE_PRECISION (valtype
) < BITS_PER_WORD
)
3565 ? SImode
: TYPE_MODE (valtype
),
3566 outgoing
? GP_OUTGOING_RETURN
: GP_RETURN
);
3569 /* Worker function for TARGET_LIBCALL_VALUE. */
3572 xtensa_libcall_value (enum machine_mode mode
, const_rtx fun ATTRIBUTE_UNUSED
)
3574 return gen_rtx_REG ((GET_MODE_CLASS (mode
) == MODE_INT
3575 && GET_MODE_SIZE (mode
) < UNITS_PER_WORD
)
3576 ? SImode
: mode
, GP_RETURN
);
3579 /* Worker function TARGET_FUNCTION_VALUE_REGNO_P. */
3582 xtensa_function_value_regno_p (const unsigned int regno
)
3584 return (regno
== GP_RETURN
);
3587 /* The static chain is passed in memory. Provide rtx giving 'mem'
3588 expressions that denote where they are stored. */
3591 xtensa_static_chain (const_tree
ARG_UNUSED (fndecl
), bool incoming_p
)
3593 rtx base
= incoming_p
? arg_pointer_rtx
: stack_pointer_rtx
;
3594 return gen_frame_mem (Pmode
, plus_constant (Pmode
, base
,
3595 -5 * UNITS_PER_WORD
));
3599 /* TRAMPOLINE_TEMPLATE: For Xtensa, the trampoline must perform an ENTRY
3600 instruction with a minimal stack frame in order to get some free
3601 registers. Once the actual call target is known, the proper stack frame
3602 size is extracted from the ENTRY instruction at the target and the
3603 current frame is adjusted to match. The trampoline then transfers
3604 control to the instruction following the ENTRY at the target. Note:
3605 this assumes that the target begins with an ENTRY instruction. */
3608 xtensa_asm_trampoline_template (FILE *stream
)
3610 bool use_call0
= (TARGET_CONST16
|| TARGET_ABSOLUTE_LITERALS
);
3612 fprintf (stream
, "\t.begin no-transform\n");
3613 fprintf (stream
, "\tentry\tsp, %d\n", MIN_FRAME_SIZE
);
3617 /* Save the return address. */
3618 fprintf (stream
, "\tmov\ta10, a0\n");
3620 /* Use a CALL0 instruction to skip past the constants and in the
3621 process get the PC into A0. This allows PC-relative access to
3622 the constants without relying on L32R. */
3623 fprintf (stream
, "\tcall0\t.Lskipconsts\n");
3626 fprintf (stream
, "\tj\t.Lskipconsts\n");
3628 fprintf (stream
, "\t.align\t4\n");
3629 fprintf (stream
, ".Lchainval:%s0\n", integer_asm_op (4, TRUE
));
3630 fprintf (stream
, ".Lfnaddr:%s0\n", integer_asm_op (4, TRUE
));
3631 fprintf (stream
, ".Lskipconsts:\n");
3633 /* Load the static chain and function address from the trampoline. */
3636 fprintf (stream
, "\taddi\ta0, a0, 3\n");
3637 fprintf (stream
, "\tl32i\ta9, a0, 0\n");
3638 fprintf (stream
, "\tl32i\ta8, a0, 4\n");
3642 fprintf (stream
, "\tl32r\ta9, .Lchainval\n");
3643 fprintf (stream
, "\tl32r\ta8, .Lfnaddr\n");
3646 /* Store the static chain. */
3647 fprintf (stream
, "\ts32i\ta9, sp, %d\n", MIN_FRAME_SIZE
- 20);
3649 /* Set the proper stack pointer value. */
3650 fprintf (stream
, "\tl32i\ta9, a8, 0\n");
3651 fprintf (stream
, "\textui\ta9, a9, %d, 12\n",
3652 TARGET_BIG_ENDIAN
? 8 : 12);
3653 fprintf (stream
, "\tslli\ta9, a9, 3\n");
3654 fprintf (stream
, "\taddi\ta9, a9, %d\n", -MIN_FRAME_SIZE
);
3655 fprintf (stream
, "\tsub\ta9, sp, a9\n");
3656 fprintf (stream
, "\tmovsp\tsp, a9\n");
3659 /* Restore the return address. */
3660 fprintf (stream
, "\tmov\ta0, a10\n");
3662 /* Jump to the instruction following the ENTRY. */
3663 fprintf (stream
, "\taddi\ta8, a8, 3\n");
3664 fprintf (stream
, "\tjx\ta8\n");
3666 /* Pad size to a multiple of TRAMPOLINE_ALIGNMENT. */
3668 fprintf (stream
, "\t.byte\t0\n");
3670 fprintf (stream
, "\tnop\n");
3672 fprintf (stream
, "\t.end no-transform\n");
3676 xtensa_trampoline_init (rtx m_tramp
, tree fndecl
, rtx chain
)
3678 rtx func
= XEXP (DECL_RTL (fndecl
), 0);
3679 bool use_call0
= (TARGET_CONST16
|| TARGET_ABSOLUTE_LITERALS
);
3680 int chain_off
= use_call0
? 12 : 8;
3681 int func_off
= use_call0
? 16 : 12;
3683 emit_block_move (m_tramp
, assemble_trampoline_template (),
3684 GEN_INT (TRAMPOLINE_SIZE
), BLOCK_OP_NORMAL
);
3686 emit_move_insn (adjust_address (m_tramp
, SImode
, chain_off
), chain
);
3687 emit_move_insn (adjust_address (m_tramp
, SImode
, func_off
), func
);
3688 emit_library_call (gen_rtx_SYMBOL_REF (Pmode
, "__xtensa_sync_caches"),
3689 LCT_NORMAL
, VOIDmode
, 1, XEXP (m_tramp
, 0), Pmode
);
3692 /* Implement TARGET_LEGITIMATE_CONSTANT_P. */
3695 xtensa_legitimate_constant_p (enum machine_mode mode ATTRIBUTE_UNUSED
, rtx x
)
3697 return !xtensa_tls_referenced_p (x
);
3700 #include "gt-xtensa.h"