OSDN Git Service

PR target/42321
[pf3gnuchains/gcc-fork.git] / gcc / config / arm / arm.c
1 /* Output routines for GCC for ARM.
2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5    Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
6    and Martin Simmons (@harleqn.co.uk).
7    More major hacks by Richard Earnshaw (rearnsha@arm.com).
8
9    This file is part of GCC.
10
11    GCC is free software; you can redistribute it and/or modify it
12    under the terms of the GNU General Public License as published
13    by the Free Software Foundation; either version 3, or (at your
14    option) any later version.
15
16    GCC is distributed in the hope that it will be useful, but WITHOUT
17    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
18    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
19    License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with GCC; see the file COPYING3.  If not see
23    <http://www.gnu.org/licenses/>.  */
24
25 #include "config.h"
26 #include "system.h"
27 #include "coretypes.h"
28 #include "tm.h"
29 #include "rtl.h"
30 #include "tree.h"
31 #include "obstack.h"
32 #include "regs.h"
33 #include "hard-reg-set.h"
34 #include "real.h"
35 #include "insn-config.h"
36 #include "conditions.h"
37 #include "output.h"
38 #include "insn-attr.h"
39 #include "flags.h"
40 #include "reload.h"
41 #include "function.h"
42 #include "expr.h"
43 #include "optabs.h"
44 #include "toplev.h"
45 #include "recog.h"
46 #include "cgraph.h"
47 #include "ggc.h"
48 #include "except.h"
49 #include "c-pragma.h"
50 #include "integrate.h"
51 #include "tm_p.h"
52 #include "target.h"
53 #include "target-def.h"
54 #include "debug.h"
55 #include "langhooks.h"
56 #include "df.h"
57 #include "intl.h"
58 #include "libfuncs.h"
59
60 /* Forward definitions of types.  */
61 typedef struct minipool_node    Mnode;
62 typedef struct minipool_fixup   Mfix;
63
64 void (*arm_lang_output_object_attributes_hook)(void);
65
66 /* Forward function declarations.  */
67 static int arm_compute_static_chain_stack_bytes (void);
68 static arm_stack_offsets *arm_get_frame_offsets (void);
69 static void arm_add_gc_roots (void);
70 static int arm_gen_constant (enum rtx_code, enum machine_mode, rtx,
71                              HOST_WIDE_INT, rtx, rtx, int, int);
72 static unsigned bit_count (unsigned long);
73 static int arm_address_register_rtx_p (rtx, int);
74 static int arm_legitimate_index_p (enum machine_mode, rtx, RTX_CODE, int);
75 static int thumb2_legitimate_index_p (enum machine_mode, rtx, int);
76 static int thumb1_base_register_rtx_p (rtx, enum machine_mode, int);
77 static rtx arm_legitimize_address (rtx, rtx, enum machine_mode);
78 static rtx thumb_legitimize_address (rtx, rtx, enum machine_mode);
79 inline static int thumb1_index_register_rtx_p (rtx, int);
80 static bool arm_legitimate_address_p (enum machine_mode, rtx, bool);
81 static int thumb_far_jump_used_p (void);
82 static bool thumb_force_lr_save (void);
83 static int const_ok_for_op (HOST_WIDE_INT, enum rtx_code);
84 static rtx emit_sfm (int, int);
85 static unsigned arm_size_return_regs (void);
86 static bool arm_assemble_integer (rtx, unsigned int, int);
87 static const char *fp_const_from_val (REAL_VALUE_TYPE *);
88 static arm_cc get_arm_condition_code (rtx);
89 static HOST_WIDE_INT int_log2 (HOST_WIDE_INT);
90 static rtx is_jump_table (rtx);
91 static const char *output_multi_immediate (rtx *, const char *, const char *,
92                                            int, HOST_WIDE_INT);
93 static const char *shift_op (rtx, HOST_WIDE_INT *);
94 static struct machine_function *arm_init_machine_status (void);
95 static void thumb_exit (FILE *, int);
96 static rtx is_jump_table (rtx);
97 static HOST_WIDE_INT get_jump_table_size (rtx);
98 static Mnode *move_minipool_fix_forward_ref (Mnode *, Mnode *, HOST_WIDE_INT);
99 static Mnode *add_minipool_forward_ref (Mfix *);
100 static Mnode *move_minipool_fix_backward_ref (Mnode *, Mnode *, HOST_WIDE_INT);
101 static Mnode *add_minipool_backward_ref (Mfix *);
102 static void assign_minipool_offsets (Mfix *);
103 static void arm_print_value (FILE *, rtx);
104 static void dump_minipool (rtx);
105 static int arm_barrier_cost (rtx);
106 static Mfix *create_fix_barrier (Mfix *, HOST_WIDE_INT);
107 static void push_minipool_barrier (rtx, HOST_WIDE_INT);
108 static void push_minipool_fix (rtx, HOST_WIDE_INT, rtx *, enum machine_mode,
109                                rtx);
110 static void arm_reorg (void);
111 static bool note_invalid_constants (rtx, HOST_WIDE_INT, int);
112 static unsigned long arm_compute_save_reg0_reg12_mask (void);
113 static unsigned long arm_compute_save_reg_mask (void);
114 static unsigned long arm_isr_value (tree);
115 static unsigned long arm_compute_func_type (void);
116 static tree arm_handle_fndecl_attribute (tree *, tree, tree, int, bool *);
117 static tree arm_handle_pcs_attribute (tree *, tree, tree, int, bool *);
118 static tree arm_handle_isr_attribute (tree *, tree, tree, int, bool *);
119 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
120 static tree arm_handle_notshared_attribute (tree *, tree, tree, int, bool *);
121 #endif
122 static void arm_output_function_epilogue (FILE *, HOST_WIDE_INT);
123 static void arm_output_function_prologue (FILE *, HOST_WIDE_INT);
124 static void thumb1_output_function_prologue (FILE *, HOST_WIDE_INT);
125 static int arm_comp_type_attributes (const_tree, const_tree);
126 static void arm_set_default_type_attributes (tree);
127 static int arm_adjust_cost (rtx, rtx, rtx, int);
128 static int count_insns_for_constant (HOST_WIDE_INT, int);
129 static int arm_get_strip_length (int);
130 static bool arm_function_ok_for_sibcall (tree, tree);
131 static enum machine_mode arm_promote_function_mode (const_tree,
132                                                     enum machine_mode, int *,
133                                                     const_tree, int);
134 static bool arm_return_in_memory (const_tree, const_tree);
135 static rtx arm_function_value (const_tree, const_tree, bool);
136 static rtx arm_libcall_value (enum machine_mode, const_rtx);
137
138 static void arm_internal_label (FILE *, const char *, unsigned long);
139 static void arm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
140                                  tree);
141 static bool arm_have_conditional_execution (void);
142 static bool arm_rtx_costs_1 (rtx, enum rtx_code, int*, bool);
143 static bool arm_size_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *);
144 static bool arm_slowmul_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
145 static bool arm_fastmul_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
146 static bool arm_xscale_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
147 static bool arm_9e_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
148 static bool arm_rtx_costs (rtx, int, int, int *, bool);
149 static int arm_address_cost (rtx, bool);
150 static bool arm_memory_load_p (rtx);
151 static bool arm_cirrus_insn_p (rtx);
152 static void cirrus_reorg (rtx);
153 static void arm_init_builtins (void);
154 static rtx arm_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
155 static void arm_init_iwmmxt_builtins (void);
156 static rtx safe_vector_operand (rtx, enum machine_mode);
157 static rtx arm_expand_binop_builtin (enum insn_code, tree, rtx);
158 static rtx arm_expand_unop_builtin (enum insn_code, tree, rtx, int);
159 static rtx arm_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
160 static void emit_constant_insn (rtx cond, rtx pattern);
161 static rtx emit_set_insn (rtx, rtx);
162 static int arm_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
163                                   tree, bool);
164 static rtx aapcs_allocate_return_reg (enum machine_mode, const_tree,
165                                       const_tree);
166 static int aapcs_select_return_coproc (const_tree, const_tree);
167
168 #ifdef OBJECT_FORMAT_ELF
169 static void arm_elf_asm_constructor (rtx, int) ATTRIBUTE_UNUSED;
170 static void arm_elf_asm_destructor (rtx, int) ATTRIBUTE_UNUSED;
171 #endif
172 #ifndef ARM_PE
173 static void arm_encode_section_info (tree, rtx, int);
174 #endif
175
176 static void arm_file_end (void);
177 static void arm_file_start (void);
178
179 static void arm_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode,
180                                         tree, int *, int);
181 static bool arm_pass_by_reference (CUMULATIVE_ARGS *,
182                                    enum machine_mode, const_tree, bool);
183 static bool arm_promote_prototypes (const_tree);
184 static bool arm_default_short_enums (void);
185 static bool arm_align_anon_bitfield (void);
186 static bool arm_return_in_msb (const_tree);
187 static bool arm_must_pass_in_stack (enum machine_mode, const_tree);
188 static bool arm_return_in_memory (const_tree, const_tree);
189 #ifdef TARGET_UNWIND_INFO
190 static void arm_unwind_emit (FILE *, rtx);
191 static bool arm_output_ttype (rtx);
192 #endif
193 static void arm_dwarf_handle_frame_unspec (const char *, rtx, int);
194 static rtx arm_dwarf_register_span (rtx);
195
196 static tree arm_cxx_guard_type (void);
197 static bool arm_cxx_guard_mask_bit (void);
198 static tree arm_get_cookie_size (tree);
199 static bool arm_cookie_has_size (void);
200 static bool arm_cxx_cdtor_returns_this (void);
201 static bool arm_cxx_key_method_may_be_inline (void);
202 static void arm_cxx_determine_class_data_visibility (tree);
203 static bool arm_cxx_class_data_always_comdat (void);
204 static bool arm_cxx_use_aeabi_atexit (void);
205 static void arm_init_libfuncs (void);
206 static tree arm_build_builtin_va_list (void);
207 static void arm_expand_builtin_va_start (tree, rtx);
208 static tree arm_gimplify_va_arg_expr (tree, tree, gimple_seq *, gimple_seq *);
209 static bool arm_handle_option (size_t, const char *, int);
210 static void arm_target_help (void);
211 static unsigned HOST_WIDE_INT arm_shift_truncation_mask (enum machine_mode);
212 static bool arm_cannot_copy_insn_p (rtx);
213 static bool arm_tls_symbol_p (rtx x);
214 static int arm_issue_rate (void);
215 static void arm_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
216 static bool arm_allocate_stack_slots_for_args (void);
217 static const char *arm_invalid_parameter_type (const_tree t);
218 static const char *arm_invalid_return_type (const_tree t);
219 static tree arm_promoted_type (const_tree t);
220 static tree arm_convert_to_type (tree type, tree expr);
221 static bool arm_scalar_mode_supported_p (enum machine_mode);
222 static bool arm_frame_pointer_required (void);
223 static bool arm_can_eliminate (const int, const int);
224 static void arm_asm_trampoline_template (FILE *);
225 static void arm_trampoline_init (rtx, tree, rtx);
226 static rtx arm_trampoline_adjust_address (rtx);
227
228 \f
229 /* Table of machine attributes.  */
230 static const struct attribute_spec arm_attribute_table[] =
231 {
232   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
233   /* Function calls made to this symbol must be done indirectly, because
234      it may lie outside of the 26 bit addressing range of a normal function
235      call.  */
236   { "long_call",    0, 0, false, true,  true,  NULL },
237   /* Whereas these functions are always known to reside within the 26 bit
238      addressing range.  */
239   { "short_call",   0, 0, false, true,  true,  NULL },
240   /* Specify the procedure call conventions for a function.  */
241   { "pcs",          1, 1, false, true,  true,  arm_handle_pcs_attribute },
242   /* Interrupt Service Routines have special prologue and epilogue requirements.  */
243   { "isr",          0, 1, false, false, false, arm_handle_isr_attribute },
244   { "interrupt",    0, 1, false, false, false, arm_handle_isr_attribute },
245   { "naked",        0, 0, true,  false, false, arm_handle_fndecl_attribute },
246 #ifdef ARM_PE
247   /* ARM/PE has three new attributes:
248      interfacearm - ?
249      dllexport - for exporting a function/variable that will live in a dll
250      dllimport - for importing a function/variable from a dll
251
252      Microsoft allows multiple declspecs in one __declspec, separating
253      them with spaces.  We do NOT support this.  Instead, use __declspec
254      multiple times.
255   */
256   { "dllimport",    0, 0, true,  false, false, NULL },
257   { "dllexport",    0, 0, true,  false, false, NULL },
258   { "interfacearm", 0, 0, true,  false, false, arm_handle_fndecl_attribute },
259 #elif TARGET_DLLIMPORT_DECL_ATTRIBUTES
260   { "dllimport",    0, 0, false, false, false, handle_dll_attribute },
261   { "dllexport",    0, 0, false, false, false, handle_dll_attribute },
262   { "notshared",    0, 0, false, true, false, arm_handle_notshared_attribute },
263 #endif
264   { NULL,           0, 0, false, false, false, NULL }
265 };
266 \f
267 /* Initialize the GCC target structure.  */
268 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
269 #undef  TARGET_MERGE_DECL_ATTRIBUTES
270 #define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
271 #endif
272
273 #undef TARGET_LEGITIMIZE_ADDRESS
274 #define TARGET_LEGITIMIZE_ADDRESS arm_legitimize_address
275
276 #undef  TARGET_ATTRIBUTE_TABLE
277 #define TARGET_ATTRIBUTE_TABLE arm_attribute_table
278
279 #undef TARGET_ASM_FILE_START
280 #define TARGET_ASM_FILE_START arm_file_start
281 #undef TARGET_ASM_FILE_END
282 #define TARGET_ASM_FILE_END arm_file_end
283
284 #undef  TARGET_ASM_ALIGNED_SI_OP
285 #define TARGET_ASM_ALIGNED_SI_OP NULL
286 #undef  TARGET_ASM_INTEGER
287 #define TARGET_ASM_INTEGER arm_assemble_integer
288
289 #undef  TARGET_ASM_FUNCTION_PROLOGUE
290 #define TARGET_ASM_FUNCTION_PROLOGUE arm_output_function_prologue
291
292 #undef  TARGET_ASM_FUNCTION_EPILOGUE
293 #define TARGET_ASM_FUNCTION_EPILOGUE arm_output_function_epilogue
294
295 #undef  TARGET_DEFAULT_TARGET_FLAGS
296 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | MASK_SCHED_PROLOG)
297 #undef  TARGET_HANDLE_OPTION
298 #define TARGET_HANDLE_OPTION arm_handle_option
299 #undef  TARGET_HELP
300 #define TARGET_HELP arm_target_help
301
302 #undef  TARGET_COMP_TYPE_ATTRIBUTES
303 #define TARGET_COMP_TYPE_ATTRIBUTES arm_comp_type_attributes
304
305 #undef  TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
306 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES arm_set_default_type_attributes
307
308 #undef  TARGET_SCHED_ADJUST_COST
309 #define TARGET_SCHED_ADJUST_COST arm_adjust_cost
310
311 #undef TARGET_ENCODE_SECTION_INFO
312 #ifdef ARM_PE
313 #define TARGET_ENCODE_SECTION_INFO  arm_pe_encode_section_info
314 #else
315 #define TARGET_ENCODE_SECTION_INFO  arm_encode_section_info
316 #endif
317
318 #undef  TARGET_STRIP_NAME_ENCODING
319 #define TARGET_STRIP_NAME_ENCODING arm_strip_name_encoding
320
321 #undef  TARGET_ASM_INTERNAL_LABEL
322 #define TARGET_ASM_INTERNAL_LABEL arm_internal_label
323
324 #undef  TARGET_FUNCTION_OK_FOR_SIBCALL
325 #define TARGET_FUNCTION_OK_FOR_SIBCALL arm_function_ok_for_sibcall
326
327 #undef  TARGET_FUNCTION_VALUE
328 #define TARGET_FUNCTION_VALUE arm_function_value
329
330 #undef  TARGET_LIBCALL_VALUE
331 #define TARGET_LIBCALL_VALUE arm_libcall_value
332
333 #undef  TARGET_ASM_OUTPUT_MI_THUNK
334 #define TARGET_ASM_OUTPUT_MI_THUNK arm_output_mi_thunk
335 #undef  TARGET_ASM_CAN_OUTPUT_MI_THUNK
336 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
337
338 #undef  TARGET_RTX_COSTS
339 #define TARGET_RTX_COSTS arm_rtx_costs
340 #undef  TARGET_ADDRESS_COST
341 #define TARGET_ADDRESS_COST arm_address_cost
342
343 #undef TARGET_SHIFT_TRUNCATION_MASK
344 #define TARGET_SHIFT_TRUNCATION_MASK arm_shift_truncation_mask
345 #undef TARGET_VECTOR_MODE_SUPPORTED_P
346 #define TARGET_VECTOR_MODE_SUPPORTED_P arm_vector_mode_supported_p
347
348 #undef  TARGET_MACHINE_DEPENDENT_REORG
349 #define TARGET_MACHINE_DEPENDENT_REORG arm_reorg
350
351 #undef  TARGET_INIT_BUILTINS
352 #define TARGET_INIT_BUILTINS  arm_init_builtins
353 #undef  TARGET_EXPAND_BUILTIN
354 #define TARGET_EXPAND_BUILTIN arm_expand_builtin
355
356 #undef TARGET_INIT_LIBFUNCS
357 #define TARGET_INIT_LIBFUNCS arm_init_libfuncs
358
359 #undef TARGET_PROMOTE_FUNCTION_MODE
360 #define TARGET_PROMOTE_FUNCTION_MODE arm_promote_function_mode
361 #undef TARGET_PROMOTE_PROTOTYPES
362 #define TARGET_PROMOTE_PROTOTYPES arm_promote_prototypes
363 #undef TARGET_PASS_BY_REFERENCE
364 #define TARGET_PASS_BY_REFERENCE arm_pass_by_reference
365 #undef TARGET_ARG_PARTIAL_BYTES
366 #define TARGET_ARG_PARTIAL_BYTES arm_arg_partial_bytes
367
368 #undef  TARGET_SETUP_INCOMING_VARARGS
369 #define TARGET_SETUP_INCOMING_VARARGS arm_setup_incoming_varargs
370
371 #undef TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS
372 #define TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS arm_allocate_stack_slots_for_args
373
374 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
375 #define TARGET_ASM_TRAMPOLINE_TEMPLATE arm_asm_trampoline_template
376 #undef TARGET_TRAMPOLINE_INIT
377 #define TARGET_TRAMPOLINE_INIT arm_trampoline_init
378 #undef TARGET_TRAMPOLINE_ADJUST_ADDRESS
379 #define TARGET_TRAMPOLINE_ADJUST_ADDRESS arm_trampoline_adjust_address
380
381 #undef TARGET_DEFAULT_SHORT_ENUMS
382 #define TARGET_DEFAULT_SHORT_ENUMS arm_default_short_enums
383
384 #undef TARGET_ALIGN_ANON_BITFIELD
385 #define TARGET_ALIGN_ANON_BITFIELD arm_align_anon_bitfield
386
387 #undef TARGET_NARROW_VOLATILE_BITFIELD
388 #define TARGET_NARROW_VOLATILE_BITFIELD hook_bool_void_false
389
390 #undef TARGET_CXX_GUARD_TYPE
391 #define TARGET_CXX_GUARD_TYPE arm_cxx_guard_type
392
393 #undef TARGET_CXX_GUARD_MASK_BIT
394 #define TARGET_CXX_GUARD_MASK_BIT arm_cxx_guard_mask_bit
395
396 #undef TARGET_CXX_GET_COOKIE_SIZE
397 #define TARGET_CXX_GET_COOKIE_SIZE arm_get_cookie_size
398
399 #undef TARGET_CXX_COOKIE_HAS_SIZE
400 #define TARGET_CXX_COOKIE_HAS_SIZE arm_cookie_has_size
401
402 #undef TARGET_CXX_CDTOR_RETURNS_THIS
403 #define TARGET_CXX_CDTOR_RETURNS_THIS arm_cxx_cdtor_returns_this
404
405 #undef TARGET_CXX_KEY_METHOD_MAY_BE_INLINE
406 #define TARGET_CXX_KEY_METHOD_MAY_BE_INLINE arm_cxx_key_method_may_be_inline
407
408 #undef TARGET_CXX_USE_AEABI_ATEXIT
409 #define TARGET_CXX_USE_AEABI_ATEXIT arm_cxx_use_aeabi_atexit
410
411 #undef TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY
412 #define TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY \
413   arm_cxx_determine_class_data_visibility
414
415 #undef TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT
416 #define TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT arm_cxx_class_data_always_comdat
417
418 #undef TARGET_RETURN_IN_MSB
419 #define TARGET_RETURN_IN_MSB arm_return_in_msb
420
421 #undef TARGET_RETURN_IN_MEMORY
422 #define TARGET_RETURN_IN_MEMORY arm_return_in_memory
423
424 #undef TARGET_MUST_PASS_IN_STACK
425 #define TARGET_MUST_PASS_IN_STACK arm_must_pass_in_stack
426
427 #ifdef TARGET_UNWIND_INFO
428 #undef TARGET_UNWIND_EMIT
429 #define TARGET_UNWIND_EMIT arm_unwind_emit
430
431 /* EABI unwinding tables use a different format for the typeinfo tables.  */
432 #undef TARGET_ASM_TTYPE
433 #define TARGET_ASM_TTYPE arm_output_ttype
434
435 #undef TARGET_ARM_EABI_UNWINDER
436 #define TARGET_ARM_EABI_UNWINDER true
437 #endif /* TARGET_UNWIND_INFO */
438
439 #undef TARGET_DWARF_HANDLE_FRAME_UNSPEC
440 #define TARGET_DWARF_HANDLE_FRAME_UNSPEC arm_dwarf_handle_frame_unspec
441
442 #undef TARGET_DWARF_REGISTER_SPAN
443 #define TARGET_DWARF_REGISTER_SPAN arm_dwarf_register_span
444
445 #undef  TARGET_CANNOT_COPY_INSN_P
446 #define TARGET_CANNOT_COPY_INSN_P arm_cannot_copy_insn_p
447
448 #ifdef HAVE_AS_TLS
449 #undef TARGET_HAVE_TLS
450 #define TARGET_HAVE_TLS true
451 #endif
452
453 #undef TARGET_HAVE_CONDITIONAL_EXECUTION
454 #define TARGET_HAVE_CONDITIONAL_EXECUTION arm_have_conditional_execution
455
456 #undef TARGET_CANNOT_FORCE_CONST_MEM
457 #define TARGET_CANNOT_FORCE_CONST_MEM arm_cannot_force_const_mem
458
459 #undef TARGET_MAX_ANCHOR_OFFSET
460 #define TARGET_MAX_ANCHOR_OFFSET 4095
461
462 /* The minimum is set such that the total size of the block
463    for a particular anchor is -4088 + 1 + 4095 bytes, which is
464    divisible by eight, ensuring natural spacing of anchors.  */
465 #undef TARGET_MIN_ANCHOR_OFFSET
466 #define TARGET_MIN_ANCHOR_OFFSET -4088
467
468 #undef TARGET_SCHED_ISSUE_RATE
469 #define TARGET_SCHED_ISSUE_RATE arm_issue_rate
470
471 #undef TARGET_MANGLE_TYPE
472 #define TARGET_MANGLE_TYPE arm_mangle_type
473
474 #undef TARGET_BUILD_BUILTIN_VA_LIST
475 #define TARGET_BUILD_BUILTIN_VA_LIST arm_build_builtin_va_list
476 #undef TARGET_EXPAND_BUILTIN_VA_START
477 #define TARGET_EXPAND_BUILTIN_VA_START arm_expand_builtin_va_start
478 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
479 #define TARGET_GIMPLIFY_VA_ARG_EXPR arm_gimplify_va_arg_expr
480
481 #ifdef HAVE_AS_TLS
482 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
483 #define TARGET_ASM_OUTPUT_DWARF_DTPREL arm_output_dwarf_dtprel
484 #endif
485
486 #undef TARGET_LEGITIMATE_ADDRESS_P
487 #define TARGET_LEGITIMATE_ADDRESS_P     arm_legitimate_address_p
488
489 #undef TARGET_INVALID_PARAMETER_TYPE
490 #define TARGET_INVALID_PARAMETER_TYPE arm_invalid_parameter_type
491
492 #undef TARGET_INVALID_RETURN_TYPE
493 #define TARGET_INVALID_RETURN_TYPE arm_invalid_return_type
494
495 #undef TARGET_PROMOTED_TYPE
496 #define TARGET_PROMOTED_TYPE arm_promoted_type
497
498 #undef TARGET_CONVERT_TO_TYPE
499 #define TARGET_CONVERT_TO_TYPE arm_convert_to_type
500
501 #undef TARGET_SCALAR_MODE_SUPPORTED_P
502 #define TARGET_SCALAR_MODE_SUPPORTED_P arm_scalar_mode_supported_p
503
504 #undef TARGET_FRAME_POINTER_REQUIRED
505 #define TARGET_FRAME_POINTER_REQUIRED arm_frame_pointer_required
506
507 #undef TARGET_CAN_ELIMINATE
508 #define TARGET_CAN_ELIMINATE arm_can_eliminate
509
510 struct gcc_target targetm = TARGET_INITIALIZER;
511 \f
512 /* Obstack for minipool constant handling.  */
513 static struct obstack minipool_obstack;
514 static char *         minipool_startobj;
515
516 /* The maximum number of insns skipped which
517    will be conditionalised if possible.  */
518 static int max_insns_skipped = 5;
519
520 extern FILE * asm_out_file;
521
522 /* True if we are currently building a constant table.  */
523 int making_const_table;
524
525 /* The processor for which instructions should be scheduled.  */
526 enum processor_type arm_tune = arm_none;
527
528 /* The default processor used if not overridden by commandline.  */
529 static enum processor_type arm_default_cpu = arm_none;
530
531 /* Which floating point hardware to schedule for.  */
532 int arm_fpu_attr;
533
534 /* Which floating popint hardware to use.  */
535 const struct arm_fpu_desc *arm_fpu_desc;
536
537 /* Whether to use floating point hardware.  */
538 enum float_abi_type arm_float_abi;
539
540 /* Which __fp16 format to use.  */
541 enum arm_fp16_format_type arm_fp16_format;
542
543 /* Which ABI to use.  */
544 enum arm_abi_type arm_abi;
545
546 /* Which thread pointer model to use.  */
547 enum arm_tp_type target_thread_pointer = TP_AUTO;
548
549 /* Used to parse -mstructure_size_boundary command line option.  */
550 int    arm_structure_size_boundary = DEFAULT_STRUCTURE_SIZE_BOUNDARY;
551
552 /* Used for Thumb call_via trampolines.  */
553 rtx thumb_call_via_label[14];
554 static int thumb_call_reg_needed;
555
556 /* Bit values used to identify processor capabilities.  */
557 #define FL_CO_PROC    (1 << 0)        /* Has external co-processor bus */
558 #define FL_ARCH3M     (1 << 1)        /* Extended multiply */
559 #define FL_MODE26     (1 << 2)        /* 26-bit mode support */
560 #define FL_MODE32     (1 << 3)        /* 32-bit mode support */
561 #define FL_ARCH4      (1 << 4)        /* Architecture rel 4 */
562 #define FL_ARCH5      (1 << 5)        /* Architecture rel 5 */
563 #define FL_THUMB      (1 << 6)        /* Thumb aware */
564 #define FL_LDSCHED    (1 << 7)        /* Load scheduling necessary */
565 #define FL_STRONG     (1 << 8)        /* StrongARM */
566 #define FL_ARCH5E     (1 << 9)        /* DSP extensions to v5 */
567 #define FL_XSCALE     (1 << 10)       /* XScale */
568 #define FL_CIRRUS     (1 << 11)       /* Cirrus/DSP.  */
569 #define FL_ARCH6      (1 << 12)       /* Architecture rel 6.  Adds
570                                          media instructions.  */
571 #define FL_VFPV2      (1 << 13)       /* Vector Floating Point V2.  */
572 #define FL_WBUF       (1 << 14)       /* Schedule for write buffer ops.
573                                          Note: ARM6 & 7 derivatives only.  */
574 #define FL_ARCH6K     (1 << 15)       /* Architecture rel 6 K extensions.  */
575 #define FL_THUMB2     (1 << 16)       /* Thumb-2.  */
576 #define FL_NOTM       (1 << 17)       /* Instructions not present in the 'M'
577                                          profile.  */
578 #define FL_DIV        (1 << 18)       /* Hardware divide.  */
579 #define FL_VFPV3      (1 << 19)       /* Vector Floating Point V3.  */
580 #define FL_NEON       (1 << 20)       /* Neon instructions.  */
581 #define FL_ARCH7EM    (1 << 21)       /* Instructions present in the ARMv7E-M
582                                          architecture.  */
583
584 #define FL_IWMMXT     (1 << 29)       /* XScale v2 or "Intel Wireless MMX technology".  */
585
586 #define FL_FOR_ARCH2    FL_NOTM
587 #define FL_FOR_ARCH3    (FL_FOR_ARCH2 | FL_MODE32)
588 #define FL_FOR_ARCH3M   (FL_FOR_ARCH3 | FL_ARCH3M)
589 #define FL_FOR_ARCH4    (FL_FOR_ARCH3M | FL_ARCH4)
590 #define FL_FOR_ARCH4T   (FL_FOR_ARCH4 | FL_THUMB)
591 #define FL_FOR_ARCH5    (FL_FOR_ARCH4 | FL_ARCH5)
592 #define FL_FOR_ARCH5T   (FL_FOR_ARCH5 | FL_THUMB)
593 #define FL_FOR_ARCH5E   (FL_FOR_ARCH5 | FL_ARCH5E)
594 #define FL_FOR_ARCH5TE  (FL_FOR_ARCH5E | FL_THUMB)
595 #define FL_FOR_ARCH5TEJ FL_FOR_ARCH5TE
596 #define FL_FOR_ARCH6    (FL_FOR_ARCH5TE | FL_ARCH6)
597 #define FL_FOR_ARCH6J   FL_FOR_ARCH6
598 #define FL_FOR_ARCH6K   (FL_FOR_ARCH6 | FL_ARCH6K)
599 #define FL_FOR_ARCH6Z   FL_FOR_ARCH6
600 #define FL_FOR_ARCH6ZK  FL_FOR_ARCH6K
601 #define FL_FOR_ARCH6T2  (FL_FOR_ARCH6 | FL_THUMB2)
602 #define FL_FOR_ARCH6M   (FL_FOR_ARCH6 & ~FL_NOTM)
603 #define FL_FOR_ARCH7    (FL_FOR_ARCH6T2 &~ FL_NOTM)
604 #define FL_FOR_ARCH7A   (FL_FOR_ARCH7 | FL_NOTM | FL_ARCH6K)
605 #define FL_FOR_ARCH7R   (FL_FOR_ARCH7A | FL_DIV)
606 #define FL_FOR_ARCH7M   (FL_FOR_ARCH7 | FL_DIV)
607 #define FL_FOR_ARCH7EM  (FL_FOR_ARCH7M | FL_ARCH7EM)
608
609 /* The bits in this mask specify which
610    instructions we are allowed to generate.  */
611 static unsigned long insn_flags = 0;
612
613 /* The bits in this mask specify which instruction scheduling options should
614    be used.  */
615 static unsigned long tune_flags = 0;
616
617 /* The following are used in the arm.md file as equivalents to bits
618    in the above two flag variables.  */
619
620 /* Nonzero if this chip supports the ARM Architecture 3M extensions.  */
621 int arm_arch3m = 0;
622
623 /* Nonzero if this chip supports the ARM Architecture 4 extensions.  */
624 int arm_arch4 = 0;
625
626 /* Nonzero if this chip supports the ARM Architecture 4t extensions.  */
627 int arm_arch4t = 0;
628
629 /* Nonzero if this chip supports the ARM Architecture 5 extensions.  */
630 int arm_arch5 = 0;
631
632 /* Nonzero if this chip supports the ARM Architecture 5E extensions.  */
633 int arm_arch5e = 0;
634
635 /* Nonzero if this chip supports the ARM Architecture 6 extensions.  */
636 int arm_arch6 = 0;
637
638 /* Nonzero if this chip supports the ARM 6K extensions.  */
639 int arm_arch6k = 0;
640
641 /* Nonzero if instructions not present in the 'M' profile can be used.  */
642 int arm_arch_notm = 0;
643
644 /* Nonzero if instructions present in ARMv7E-M can be used.  */
645 int arm_arch7em = 0;
646
647 /* Nonzero if this chip can benefit from load scheduling.  */
648 int arm_ld_sched = 0;
649
650 /* Nonzero if this chip is a StrongARM.  */
651 int arm_tune_strongarm = 0;
652
653 /* Nonzero if this chip is a Cirrus variant.  */
654 int arm_arch_cirrus = 0;
655
656 /* Nonzero if this chip supports Intel Wireless MMX technology.  */
657 int arm_arch_iwmmxt = 0;
658
659 /* Nonzero if this chip is an XScale.  */
660 int arm_arch_xscale = 0;
661
662 /* Nonzero if tuning for XScale  */
663 int arm_tune_xscale = 0;
664
665 /* Nonzero if we want to tune for stores that access the write-buffer.
666    This typically means an ARM6 or ARM7 with MMU or MPU.  */
667 int arm_tune_wbuf = 0;
668
669 /* Nonzero if tuning for Cortex-A9.  */
670 int arm_tune_cortex_a9 = 0;
671
672 /* Nonzero if generating Thumb instructions.  */
673 int thumb_code = 0;
674
675 /* Nonzero if we should define __THUMB_INTERWORK__ in the
676    preprocessor.
677    XXX This is a bit of a hack, it's intended to help work around
678    problems in GLD which doesn't understand that armv5t code is
679    interworking clean.  */
680 int arm_cpp_interwork = 0;
681
682 /* Nonzero if chip supports Thumb 2.  */
683 int arm_arch_thumb2;
684
685 /* Nonzero if chip supports integer division instruction.  */
686 int arm_arch_hwdiv;
687
688 /* In case of a PRE_INC, POST_INC, PRE_DEC, POST_DEC memory reference, we
689    must report the mode of the memory reference from PRINT_OPERAND to
690    PRINT_OPERAND_ADDRESS.  */
691 enum machine_mode output_memory_reference_mode;
692
693 /* The register number to be used for the PIC offset register.  */
694 unsigned arm_pic_register = INVALID_REGNUM;
695
696 /* Set to 1 after arm_reorg has started.  Reset to start at the start of
697    the next function.  */
698 static int after_arm_reorg = 0;
699
700 /* The maximum number of insns to be used when loading a constant.  */
701 static int arm_constant_limit = 3;
702
703 static enum arm_pcs arm_pcs_default;
704
705 /* For an explanation of these variables, see final_prescan_insn below.  */
706 int arm_ccfsm_state;
707 /* arm_current_cc is also used for Thumb-2 cond_exec blocks.  */
708 enum arm_cond_code arm_current_cc;
709 rtx arm_target_insn;
710 int arm_target_label;
711 /* The number of conditionally executed insns, including the current insn.  */
712 int arm_condexec_count = 0;
713 /* A bitmask specifying the patterns for the IT block.
714    Zero means do not output an IT block before this insn. */
715 int arm_condexec_mask = 0;
716 /* The number of bits used in arm_condexec_mask.  */
717 int arm_condexec_masklen = 0;
718
719 /* The condition codes of the ARM, and the inverse function.  */
720 static const char * const arm_condition_codes[] =
721 {
722   "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
723   "hi", "ls", "ge", "lt", "gt", "le", "al", "nv"
724 };
725
726 #define ARM_LSL_NAME (TARGET_UNIFIED_ASM ? "lsl" : "asl")
727 #define streq(string1, string2) (strcmp (string1, string2) == 0)
728
729 #define THUMB2_WORK_REGS (0xff & ~(  (1 << THUMB_HARD_FRAME_POINTER_REGNUM) \
730                                    | (1 << SP_REGNUM) | (1 << PC_REGNUM) \
731                                    | (1 << PIC_OFFSET_TABLE_REGNUM)))
732 \f
733 /* Initialization code.  */
734
735 struct processors
736 {
737   const char *const name;
738   enum processor_type core;
739   const char *arch;
740   const unsigned long flags;
741   bool (* rtx_costs) (rtx, enum rtx_code, enum rtx_code, int *, bool);
742 };
743
744 /* Not all of these give usefully different compilation alternatives,
745    but there is no simple way of generalizing them.  */
746 static const struct processors all_cores[] =
747 {
748   /* ARM Cores */
749 #define ARM_CORE(NAME, IDENT, ARCH, FLAGS, COSTS) \
750   {NAME, arm_none, #ARCH, FLAGS | FL_FOR_ARCH##ARCH, arm_##COSTS##_rtx_costs},
751 #include "arm-cores.def"
752 #undef ARM_CORE
753   {NULL, arm_none, NULL, 0, NULL}
754 };
755
756 static const struct processors all_architectures[] =
757 {
758   /* ARM Architectures */
759   /* We don't specify rtx_costs here as it will be figured out
760      from the core.  */
761
762   {"armv2",   arm2,       "2",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH2, NULL},
763   {"armv2a",  arm2,       "2",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH2, NULL},
764   {"armv3",   arm6,       "3",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH3, NULL},
765   {"armv3m",  arm7m,      "3M",  FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH3M, NULL},
766   {"armv4",   arm7tdmi,   "4",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH4, NULL},
767   /* Strictly, FL_MODE26 is a permitted option for v4t, but there are no
768      implementations that support it, so we will leave it out for now.  */
769   {"armv4t",  arm7tdmi,   "4T",  FL_CO_PROC |             FL_FOR_ARCH4T, NULL},
770   {"armv5",   arm10tdmi,  "5",   FL_CO_PROC |             FL_FOR_ARCH5, NULL},
771   {"armv5t",  arm10tdmi,  "5T",  FL_CO_PROC |             FL_FOR_ARCH5T, NULL},
772   {"armv5e",  arm1026ejs, "5E",  FL_CO_PROC |             FL_FOR_ARCH5E, NULL},
773   {"armv5te", arm1026ejs, "5TE", FL_CO_PROC |             FL_FOR_ARCH5TE, NULL},
774   {"armv6",   arm1136js,  "6",   FL_CO_PROC |             FL_FOR_ARCH6, NULL},
775   {"armv6j",  arm1136js,  "6J",  FL_CO_PROC |             FL_FOR_ARCH6J, NULL},
776   {"armv6k",  mpcore,     "6K",  FL_CO_PROC |             FL_FOR_ARCH6K, NULL},
777   {"armv6z",  arm1176jzs, "6Z",  FL_CO_PROC |             FL_FOR_ARCH6Z, NULL},
778   {"armv6zk", arm1176jzs, "6ZK", FL_CO_PROC |             FL_FOR_ARCH6ZK, NULL},
779   {"armv6t2", arm1156t2s, "6T2", FL_CO_PROC |             FL_FOR_ARCH6T2, NULL},
780   {"armv6-m", cortexm1,   "6M",                           FL_FOR_ARCH6M, NULL},
781   {"armv7",   cortexa8,   "7",   FL_CO_PROC |             FL_FOR_ARCH7, NULL},
782   {"armv7-a", cortexa8,   "7A",  FL_CO_PROC |             FL_FOR_ARCH7A, NULL},
783   {"armv7-r", cortexr4,   "7R",  FL_CO_PROC |             FL_FOR_ARCH7R, NULL},
784   {"armv7-m", cortexm3,   "7M",  FL_CO_PROC |             FL_FOR_ARCH7M, NULL},
785   {"armv7e-m",   cortexm3, "7EM", FL_CO_PROC |            FL_FOR_ARCH7EM, NULL},
786   {"ep9312",  ep9312,     "4T",  FL_LDSCHED | FL_CIRRUS | FL_FOR_ARCH4, NULL},
787   {"iwmmxt",  iwmmxt,     "5TE", FL_LDSCHED | FL_STRONG | FL_FOR_ARCH5TE | FL_XSCALE | FL_IWMMXT , NULL},
788   {"iwmmxt2", iwmmxt2,     "5TE", FL_LDSCHED | FL_STRONG | FL_FOR_ARCH5TE | FL_XSCALE | FL_IWMMXT , NULL},
789   {NULL, arm_none, NULL, 0 , NULL}
790 };
791
792 struct arm_cpu_select
793 {
794   const char *              string;
795   const char *              name;
796   const struct processors * processors;
797 };
798
799 /* This is a magic structure.  The 'string' field is magically filled in
800    with a pointer to the value specified by the user on the command line
801    assuming that the user has specified such a value.  */
802
803 static struct arm_cpu_select arm_select[] =
804 {
805   /* string       name            processors  */
806   { NULL,       "-mcpu=",       all_cores  },
807   { NULL,       "-march=",      all_architectures },
808   { NULL,       "-mtune=",      all_cores }
809 };
810
811 /* Defines representing the indexes into the above table.  */
812 #define ARM_OPT_SET_CPU 0
813 #define ARM_OPT_SET_ARCH 1
814 #define ARM_OPT_SET_TUNE 2
815
816 /* The name of the preprocessor macro to define for this architecture.  */
817
818 char arm_arch_name[] = "__ARM_ARCH_0UNK__";
819
820 /* Available values for -mfpu=.  */
821
822 static const struct arm_fpu_desc all_fpus[] =
823 {
824   {"fpa",               ARM_FP_MODEL_FPA, 0, VFP_NONE, false, false},
825   {"fpe2",              ARM_FP_MODEL_FPA, 2, VFP_NONE, false, false},
826   {"fpe3",              ARM_FP_MODEL_FPA, 3, VFP_NONE, false, false},
827   {"maverick",          ARM_FP_MODEL_MAVERICK, 0, VFP_NONE, false, false},
828   {"vfp",               ARM_FP_MODEL_VFP, 2, VFP_REG_D16, false, false},
829   {"vfpv3",             ARM_FP_MODEL_VFP, 3, VFP_REG_D32, false, false},
830   {"vfpv3-fp16",        ARM_FP_MODEL_VFP, 3, VFP_REG_D32, false, true},
831   {"vfpv3-d16",         ARM_FP_MODEL_VFP, 3, VFP_REG_D16, false, false},
832   {"vfpv3-d16-fp16",    ARM_FP_MODEL_VFP, 3, VFP_REG_D16, false, true},
833   {"vfpv3xd",           ARM_FP_MODEL_VFP, 3, VFP_REG_SINGLE, false, false},
834   {"vfpv3xd-fp16",      ARM_FP_MODEL_VFP, 3, VFP_REG_SINGLE, false, true},
835   {"neon",              ARM_FP_MODEL_VFP, 3, VFP_REG_D32, true , false},
836   {"neon-fp16",         ARM_FP_MODEL_VFP, 3, VFP_REG_D32, true , true },
837   {"vfpv4",             ARM_FP_MODEL_VFP, 4, VFP_REG_D32, false, true},
838   {"vfpv4-d16",         ARM_FP_MODEL_VFP, 4, VFP_REG_D16, false, true},
839   {"fpv4-sp-d16",       ARM_FP_MODEL_VFP, 4, VFP_REG_SINGLE, false, true},
840   {"neon-vfpv4",        ARM_FP_MODEL_VFP, 4, VFP_REG_D32, true, true},
841   /* Compatibility aliases.  */
842   {"vfp3",              ARM_FP_MODEL_VFP, 3, VFP_REG_D32, false, false},
843 };
844
845
846 struct float_abi
847 {
848   const char * name;
849   enum float_abi_type abi_type;
850 };
851
852
853 /* Available values for -mfloat-abi=.  */
854
855 static const struct float_abi all_float_abis[] =
856 {
857   {"soft",      ARM_FLOAT_ABI_SOFT},
858   {"softfp",    ARM_FLOAT_ABI_SOFTFP},
859   {"hard",      ARM_FLOAT_ABI_HARD}
860 };
861
862
863 struct fp16_format
864 {
865   const char *name;
866   enum arm_fp16_format_type fp16_format_type;
867 };
868
869
870 /* Available values for -mfp16-format=.  */
871
872 static const struct fp16_format all_fp16_formats[] =
873 {
874   {"none",              ARM_FP16_FORMAT_NONE},
875   {"ieee",              ARM_FP16_FORMAT_IEEE},
876   {"alternative",       ARM_FP16_FORMAT_ALTERNATIVE}
877 };
878
879
880 struct abi_name
881 {
882   const char *name;
883   enum arm_abi_type abi_type;
884 };
885
886
887 /* Available values for -mabi=.  */
888
889 static const struct abi_name arm_all_abis[] =
890 {
891   {"apcs-gnu",    ARM_ABI_APCS},
892   {"atpcs",   ARM_ABI_ATPCS},
893   {"aapcs",   ARM_ABI_AAPCS},
894   {"iwmmxt",  ARM_ABI_IWMMXT},
895   {"aapcs-linux",   ARM_ABI_AAPCS_LINUX}
896 };
897
898 /* Supported TLS relocations.  */
899
900 enum tls_reloc {
901   TLS_GD32,
902   TLS_LDM32,
903   TLS_LDO32,
904   TLS_IE32,
905   TLS_LE32
906 };
907
908 /* Emit an insn that's a simple single-set.  Both the operands must be known
909    to be valid.  */
910 inline static rtx
911 emit_set_insn (rtx x, rtx y)
912 {
913   return emit_insn (gen_rtx_SET (VOIDmode, x, y));
914 }
915
916 /* Return the number of bits set in VALUE.  */
917 static unsigned
918 bit_count (unsigned long value)
919 {
920   unsigned long count = 0;
921
922   while (value)
923     {
924       count++;
925       value &= value - 1;  /* Clear the least-significant set bit.  */
926     }
927
928   return count;
929 }
930
931 /* Set up library functions unique to ARM.  */
932
933 static void
934 arm_init_libfuncs (void)
935 {
936   /* There are no special library functions unless we are using the
937      ARM BPABI.  */
938   if (!TARGET_BPABI)
939     return;
940
941   /* The functions below are described in Section 4 of the "Run-Time
942      ABI for the ARM architecture", Version 1.0.  */
943
944   /* Double-precision floating-point arithmetic.  Table 2.  */
945   set_optab_libfunc (add_optab, DFmode, "__aeabi_dadd");
946   set_optab_libfunc (sdiv_optab, DFmode, "__aeabi_ddiv");
947   set_optab_libfunc (smul_optab, DFmode, "__aeabi_dmul");
948   set_optab_libfunc (neg_optab, DFmode, "__aeabi_dneg");
949   set_optab_libfunc (sub_optab, DFmode, "__aeabi_dsub");
950
951   /* Double-precision comparisons.  Table 3.  */
952   set_optab_libfunc (eq_optab, DFmode, "__aeabi_dcmpeq");
953   set_optab_libfunc (ne_optab, DFmode, NULL);
954   set_optab_libfunc (lt_optab, DFmode, "__aeabi_dcmplt");
955   set_optab_libfunc (le_optab, DFmode, "__aeabi_dcmple");
956   set_optab_libfunc (ge_optab, DFmode, "__aeabi_dcmpge");
957   set_optab_libfunc (gt_optab, DFmode, "__aeabi_dcmpgt");
958   set_optab_libfunc (unord_optab, DFmode, "__aeabi_dcmpun");
959
960   /* Single-precision floating-point arithmetic.  Table 4.  */
961   set_optab_libfunc (add_optab, SFmode, "__aeabi_fadd");
962   set_optab_libfunc (sdiv_optab, SFmode, "__aeabi_fdiv");
963   set_optab_libfunc (smul_optab, SFmode, "__aeabi_fmul");
964   set_optab_libfunc (neg_optab, SFmode, "__aeabi_fneg");
965   set_optab_libfunc (sub_optab, SFmode, "__aeabi_fsub");
966
967   /* Single-precision comparisons.  Table 5.  */
968   set_optab_libfunc (eq_optab, SFmode, "__aeabi_fcmpeq");
969   set_optab_libfunc (ne_optab, SFmode, NULL);
970   set_optab_libfunc (lt_optab, SFmode, "__aeabi_fcmplt");
971   set_optab_libfunc (le_optab, SFmode, "__aeabi_fcmple");
972   set_optab_libfunc (ge_optab, SFmode, "__aeabi_fcmpge");
973   set_optab_libfunc (gt_optab, SFmode, "__aeabi_fcmpgt");
974   set_optab_libfunc (unord_optab, SFmode, "__aeabi_fcmpun");
975
976   /* Floating-point to integer conversions.  Table 6.  */
977   set_conv_libfunc (sfix_optab, SImode, DFmode, "__aeabi_d2iz");
978   set_conv_libfunc (ufix_optab, SImode, DFmode, "__aeabi_d2uiz");
979   set_conv_libfunc (sfix_optab, DImode, DFmode, "__aeabi_d2lz");
980   set_conv_libfunc (ufix_optab, DImode, DFmode, "__aeabi_d2ulz");
981   set_conv_libfunc (sfix_optab, SImode, SFmode, "__aeabi_f2iz");
982   set_conv_libfunc (ufix_optab, SImode, SFmode, "__aeabi_f2uiz");
983   set_conv_libfunc (sfix_optab, DImode, SFmode, "__aeabi_f2lz");
984   set_conv_libfunc (ufix_optab, DImode, SFmode, "__aeabi_f2ulz");
985
986   /* Conversions between floating types.  Table 7.  */
987   set_conv_libfunc (trunc_optab, SFmode, DFmode, "__aeabi_d2f");
988   set_conv_libfunc (sext_optab, DFmode, SFmode, "__aeabi_f2d");
989
990   /* Integer to floating-point conversions.  Table 8.  */
991   set_conv_libfunc (sfloat_optab, DFmode, SImode, "__aeabi_i2d");
992   set_conv_libfunc (ufloat_optab, DFmode, SImode, "__aeabi_ui2d");
993   set_conv_libfunc (sfloat_optab, DFmode, DImode, "__aeabi_l2d");
994   set_conv_libfunc (ufloat_optab, DFmode, DImode, "__aeabi_ul2d");
995   set_conv_libfunc (sfloat_optab, SFmode, SImode, "__aeabi_i2f");
996   set_conv_libfunc (ufloat_optab, SFmode, SImode, "__aeabi_ui2f");
997   set_conv_libfunc (sfloat_optab, SFmode, DImode, "__aeabi_l2f");
998   set_conv_libfunc (ufloat_optab, SFmode, DImode, "__aeabi_ul2f");
999
1000   /* Long long.  Table 9.  */
1001   set_optab_libfunc (smul_optab, DImode, "__aeabi_lmul");
1002   set_optab_libfunc (sdivmod_optab, DImode, "__aeabi_ldivmod");
1003   set_optab_libfunc (udivmod_optab, DImode, "__aeabi_uldivmod");
1004   set_optab_libfunc (ashl_optab, DImode, "__aeabi_llsl");
1005   set_optab_libfunc (lshr_optab, DImode, "__aeabi_llsr");
1006   set_optab_libfunc (ashr_optab, DImode, "__aeabi_lasr");
1007   set_optab_libfunc (cmp_optab, DImode, "__aeabi_lcmp");
1008   set_optab_libfunc (ucmp_optab, DImode, "__aeabi_ulcmp");
1009
1010   /* Integer (32/32->32) division.  \S 4.3.1.  */
1011   set_optab_libfunc (sdivmod_optab, SImode, "__aeabi_idivmod");
1012   set_optab_libfunc (udivmod_optab, SImode, "__aeabi_uidivmod");
1013
1014   /* The divmod functions are designed so that they can be used for
1015      plain division, even though they return both the quotient and the
1016      remainder.  The quotient is returned in the usual location (i.e.,
1017      r0 for SImode, {r0, r1} for DImode), just as would be expected
1018      for an ordinary division routine.  Because the AAPCS calling
1019      conventions specify that all of { r0, r1, r2, r3 } are
1020      callee-saved registers, there is no need to tell the compiler
1021      explicitly that those registers are clobbered by these
1022      routines.  */
1023   set_optab_libfunc (sdiv_optab, DImode, "__aeabi_ldivmod");
1024   set_optab_libfunc (udiv_optab, DImode, "__aeabi_uldivmod");
1025
1026   /* For SImode division the ABI provides div-without-mod routines,
1027      which are faster.  */
1028   set_optab_libfunc (sdiv_optab, SImode, "__aeabi_idiv");
1029   set_optab_libfunc (udiv_optab, SImode, "__aeabi_uidiv");
1030
1031   /* We don't have mod libcalls.  Fortunately gcc knows how to use the
1032      divmod libcalls instead.  */
1033   set_optab_libfunc (smod_optab, DImode, NULL);
1034   set_optab_libfunc (umod_optab, DImode, NULL);
1035   set_optab_libfunc (smod_optab, SImode, NULL);
1036   set_optab_libfunc (umod_optab, SImode, NULL);
1037
1038   /* Half-precision float operations.  The compiler handles all operations
1039      with NULL libfuncs by converting the SFmode.  */
1040   switch (arm_fp16_format)
1041     {
1042     case ARM_FP16_FORMAT_IEEE:
1043     case ARM_FP16_FORMAT_ALTERNATIVE:
1044
1045       /* Conversions.  */
1046       set_conv_libfunc (trunc_optab, HFmode, SFmode,
1047                         (arm_fp16_format == ARM_FP16_FORMAT_IEEE
1048                          ? "__gnu_f2h_ieee"
1049                          : "__gnu_f2h_alternative"));
1050       set_conv_libfunc (sext_optab, SFmode, HFmode, 
1051                         (arm_fp16_format == ARM_FP16_FORMAT_IEEE
1052                          ? "__gnu_h2f_ieee"
1053                          : "__gnu_h2f_alternative"));
1054       
1055       /* Arithmetic.  */
1056       set_optab_libfunc (add_optab, HFmode, NULL);
1057       set_optab_libfunc (sdiv_optab, HFmode, NULL);
1058       set_optab_libfunc (smul_optab, HFmode, NULL);
1059       set_optab_libfunc (neg_optab, HFmode, NULL);
1060       set_optab_libfunc (sub_optab, HFmode, NULL);
1061
1062       /* Comparisons.  */
1063       set_optab_libfunc (eq_optab, HFmode, NULL);
1064       set_optab_libfunc (ne_optab, HFmode, NULL);
1065       set_optab_libfunc (lt_optab, HFmode, NULL);
1066       set_optab_libfunc (le_optab, HFmode, NULL);
1067       set_optab_libfunc (ge_optab, HFmode, NULL);
1068       set_optab_libfunc (gt_optab, HFmode, NULL);
1069       set_optab_libfunc (unord_optab, HFmode, NULL);
1070       break;
1071
1072     default:
1073       break;
1074     }
1075
1076   if (TARGET_AAPCS_BASED)
1077     synchronize_libfunc = init_one_libfunc ("__sync_synchronize");
1078 }
1079
1080 /* On AAPCS systems, this is the "struct __va_list".  */
1081 static GTY(()) tree va_list_type;
1082
1083 /* Return the type to use as __builtin_va_list.  */
1084 static tree
1085 arm_build_builtin_va_list (void)
1086 {
1087   tree va_list_name;
1088   tree ap_field;
1089   
1090   if (!TARGET_AAPCS_BASED)
1091     return std_build_builtin_va_list ();
1092
1093   /* AAPCS \S 7.1.4 requires that va_list be a typedef for a type
1094      defined as:
1095
1096        struct __va_list 
1097        {
1098          void *__ap;
1099        };
1100
1101      The C Library ABI further reinforces this definition in \S
1102      4.1.
1103
1104      We must follow this definition exactly.  The structure tag
1105      name is visible in C++ mangled names, and thus forms a part
1106      of the ABI.  The field name may be used by people who
1107      #include <stdarg.h>.  */
1108   /* Create the type.  */
1109   va_list_type = lang_hooks.types.make_type (RECORD_TYPE);
1110   /* Give it the required name.  */
1111   va_list_name = build_decl (BUILTINS_LOCATION,
1112                              TYPE_DECL,
1113                              get_identifier ("__va_list"),
1114                              va_list_type);
1115   DECL_ARTIFICIAL (va_list_name) = 1;
1116   TYPE_NAME (va_list_type) = va_list_name;
1117   /* Create the __ap field.  */
1118   ap_field = build_decl (BUILTINS_LOCATION,
1119                          FIELD_DECL, 
1120                          get_identifier ("__ap"),
1121                          ptr_type_node);
1122   DECL_ARTIFICIAL (ap_field) = 1;
1123   DECL_FIELD_CONTEXT (ap_field) = va_list_type;
1124   TYPE_FIELDS (va_list_type) = ap_field;
1125   /* Compute its layout.  */
1126   layout_type (va_list_type);
1127
1128   return va_list_type;
1129 }
1130
1131 /* Return an expression of type "void *" pointing to the next
1132    available argument in a variable-argument list.  VALIST is the
1133    user-level va_list object, of type __builtin_va_list.  */
1134 static tree
1135 arm_extract_valist_ptr (tree valist)
1136 {
1137   if (TREE_TYPE (valist) == error_mark_node)
1138     return error_mark_node;
1139
1140   /* On an AAPCS target, the pointer is stored within "struct
1141      va_list".  */
1142   if (TARGET_AAPCS_BASED)
1143     {
1144       tree ap_field = TYPE_FIELDS (TREE_TYPE (valist));
1145       valist = build3 (COMPONENT_REF, TREE_TYPE (ap_field), 
1146                        valist, ap_field, NULL_TREE);
1147     }
1148
1149   return valist;
1150 }
1151
1152 /* Implement TARGET_EXPAND_BUILTIN_VA_START.  */
1153 static void
1154 arm_expand_builtin_va_start (tree valist, rtx nextarg)
1155 {
1156   valist = arm_extract_valist_ptr (valist);
1157   std_expand_builtin_va_start (valist, nextarg);
1158 }
1159
1160 /* Implement TARGET_GIMPLIFY_VA_ARG_EXPR.  */
1161 static tree
1162 arm_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p, 
1163                           gimple_seq *post_p)
1164 {
1165   valist = arm_extract_valist_ptr (valist);
1166   return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
1167 }
1168
1169 /* Implement TARGET_HANDLE_OPTION.  */
1170
1171 static bool
1172 arm_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
1173 {
1174   switch (code)
1175     {
1176     case OPT_march_:
1177       arm_select[1].string = arg;
1178       return true;
1179
1180     case OPT_mcpu_:
1181       arm_select[0].string = arg;
1182       return true;
1183
1184     case OPT_mhard_float:
1185       target_float_abi_name = "hard";
1186       return true;
1187
1188     case OPT_msoft_float:
1189       target_float_abi_name = "soft";
1190       return true;
1191
1192     case OPT_mtune_:
1193       arm_select[2].string = arg;
1194       return true;
1195
1196     default:
1197       return true;
1198     }
1199 }
1200
1201 static void
1202 arm_target_help (void)
1203 {
1204   int i;
1205   static int columns = 0;
1206   int remaining;
1207
1208   /* If we have not done so already, obtain the desired maximum width of
1209      the output.  Note - this is a duplication of the code at the start of
1210      gcc/opts.c:print_specific_help() - the two copies should probably be
1211      replaced by a single function.  */
1212   if (columns == 0)
1213     {
1214       const char *p;
1215
1216       GET_ENVIRONMENT (p, "COLUMNS");
1217       if (p != NULL)
1218         {
1219           int value = atoi (p);
1220
1221           if (value > 0)
1222             columns = value;
1223         }
1224
1225       if (columns == 0)
1226         /* Use a reasonable default.  */
1227         columns = 80;
1228     }
1229
1230   printf ("  Known ARM CPUs (for use with the -mcpu= and -mtune= options):\n");
1231
1232   /* The - 2 is because we know that the last entry in the array is NULL.  */
1233   i = ARRAY_SIZE (all_cores) - 2;
1234   gcc_assert (i > 0);
1235   printf ("    %s", all_cores[i].name);
1236   remaining = columns - (strlen (all_cores[i].name) + 4);
1237   gcc_assert (remaining >= 0);
1238
1239   while (i--)
1240     {
1241       int len = strlen (all_cores[i].name);
1242
1243       if (remaining > len + 2)
1244         {
1245           printf (", %s", all_cores[i].name);
1246           remaining -= len + 2;
1247         }
1248       else
1249         {
1250           if (remaining > 0)
1251             printf (",");
1252           printf ("\n    %s", all_cores[i].name);
1253           remaining = columns - (len + 4);
1254         }
1255     }
1256
1257   printf ("\n\n  Known ARM architectures (for use with the -march= option):\n");
1258
1259   i = ARRAY_SIZE (all_architectures) - 2;
1260   gcc_assert (i > 0);
1261   
1262   printf ("    %s", all_architectures[i].name);
1263   remaining = columns - (strlen (all_architectures[i].name) + 4);
1264   gcc_assert (remaining >= 0);
1265
1266   while (i--)
1267     {
1268       int len = strlen (all_architectures[i].name);
1269
1270       if (remaining > len + 2)
1271         {
1272           printf (", %s", all_architectures[i].name);
1273           remaining -= len + 2;
1274         }
1275       else
1276         {
1277           if (remaining > 0)
1278             printf (",");
1279           printf ("\n    %s", all_architectures[i].name);
1280           remaining = columns - (len + 4);
1281         }
1282     }
1283   printf ("\n");
1284
1285 }
1286
1287 /* Fix up any incompatible options that the user has specified.
1288    This has now turned into a maze.  */
1289 void
1290 arm_override_options (void)
1291 {
1292   unsigned i;
1293   enum processor_type target_arch_cpu = arm_none;
1294   enum processor_type selected_cpu = arm_none;
1295
1296   /* Set up the flags based on the cpu/architecture selected by the user.  */
1297   for (i = ARRAY_SIZE (arm_select); i--;)
1298     {
1299       struct arm_cpu_select * ptr = arm_select + i;
1300
1301       if (ptr->string != NULL && ptr->string[0] != '\0')
1302         {
1303           const struct processors * sel;
1304
1305           for (sel = ptr->processors; sel->name != NULL; sel++)
1306             if (streq (ptr->string, sel->name))
1307               {
1308                 /* Set the architecture define.  */
1309                 if (i != ARM_OPT_SET_TUNE)
1310                   sprintf (arm_arch_name, "__ARM_ARCH_%s__", sel->arch);
1311
1312                 /* Determine the processor core for which we should
1313                    tune code-generation.  */
1314                 if (/* -mcpu= is a sensible default.  */
1315                     i == ARM_OPT_SET_CPU
1316                     /* -mtune= overrides -mcpu= and -march=.  */
1317                     || i == ARM_OPT_SET_TUNE)
1318                   arm_tune = (enum processor_type) (sel - ptr->processors);
1319
1320                 /* Remember the CPU associated with this architecture.
1321                    If no other option is used to set the CPU type,
1322                    we'll use this to guess the most suitable tuning
1323                    options.  */
1324                 if (i == ARM_OPT_SET_ARCH)
1325                   target_arch_cpu = sel->core;
1326
1327                 if (i == ARM_OPT_SET_CPU)
1328                   selected_cpu = (enum processor_type) (sel - ptr->processors);
1329                   
1330                 if (i != ARM_OPT_SET_TUNE)
1331                   {
1332                     /* If we have been given an architecture and a processor
1333                        make sure that they are compatible.  We only generate
1334                        a warning though, and we prefer the CPU over the
1335                        architecture.  */
1336                     if (insn_flags != 0 && (insn_flags ^ sel->flags))
1337                       warning (0, "switch -mcpu=%s conflicts with -march= switch",
1338                                ptr->string);
1339
1340                     insn_flags = sel->flags;
1341                   }
1342
1343                 break;
1344               }
1345
1346           if (sel->name == NULL)
1347             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
1348         }
1349     }
1350
1351   /* Guess the tuning options from the architecture if necessary.  */
1352   if (arm_tune == arm_none)
1353     arm_tune = target_arch_cpu;
1354
1355   /* If the user did not specify a processor, choose one for them.  */
1356   if (insn_flags == 0)
1357     {
1358       const struct processors * sel;
1359       unsigned int        sought;
1360
1361       selected_cpu = (enum processor_type) TARGET_CPU_DEFAULT;
1362       if (selected_cpu == arm_none)
1363         {
1364 #ifdef SUBTARGET_CPU_DEFAULT
1365           /* Use the subtarget default CPU if none was specified by
1366              configure.  */
1367           selected_cpu = (enum processor_type) SUBTARGET_CPU_DEFAULT;
1368 #endif
1369           /* Default to ARM6.  */
1370           if (selected_cpu == arm_none)
1371             selected_cpu = arm6;
1372         }
1373       sel = &all_cores[selected_cpu];
1374
1375       insn_flags = sel->flags;
1376
1377       /* Now check to see if the user has specified some command line
1378          switch that require certain abilities from the cpu.  */
1379       sought = 0;
1380
1381       if (TARGET_INTERWORK || TARGET_THUMB)
1382         {
1383           sought |= (FL_THUMB | FL_MODE32);
1384
1385           /* There are no ARM processors that support both APCS-26 and
1386              interworking.  Therefore we force FL_MODE26 to be removed
1387              from insn_flags here (if it was set), so that the search
1388              below will always be able to find a compatible processor.  */
1389           insn_flags &= ~FL_MODE26;
1390         }
1391
1392       if (sought != 0 && ((sought & insn_flags) != sought))
1393         {
1394           /* Try to locate a CPU type that supports all of the abilities
1395              of the default CPU, plus the extra abilities requested by
1396              the user.  */
1397           for (sel = all_cores; sel->name != NULL; sel++)
1398             if ((sel->flags & sought) == (sought | insn_flags))
1399               break;
1400
1401           if (sel->name == NULL)
1402             {
1403               unsigned current_bit_count = 0;
1404               const struct processors * best_fit = NULL;
1405
1406               /* Ideally we would like to issue an error message here
1407                  saying that it was not possible to find a CPU compatible
1408                  with the default CPU, but which also supports the command
1409                  line options specified by the programmer, and so they
1410                  ought to use the -mcpu=<name> command line option to
1411                  override the default CPU type.
1412
1413                  If we cannot find a cpu that has both the
1414                  characteristics of the default cpu and the given
1415                  command line options we scan the array again looking
1416                  for a best match.  */
1417               for (sel = all_cores; sel->name != NULL; sel++)
1418                 if ((sel->flags & sought) == sought)
1419                   {
1420                     unsigned count;
1421
1422                     count = bit_count (sel->flags & insn_flags);
1423
1424                     if (count >= current_bit_count)
1425                       {
1426                         best_fit = sel;
1427                         current_bit_count = count;
1428                       }
1429                   }
1430
1431               gcc_assert (best_fit);
1432               sel = best_fit;
1433             }
1434
1435           insn_flags = sel->flags;
1436         }
1437       sprintf (arm_arch_name, "__ARM_ARCH_%s__", sel->arch);
1438       arm_default_cpu = (enum processor_type) (sel - all_cores);
1439       if (arm_tune == arm_none)
1440         arm_tune = arm_default_cpu;
1441     }
1442
1443   /* The processor for which we should tune should now have been
1444      chosen.  */
1445   gcc_assert (arm_tune != arm_none);
1446
1447   tune_flags = all_cores[(int)arm_tune].flags;
1448
1449   if (target_fp16_format_name)
1450     {
1451       for (i = 0; i < ARRAY_SIZE (all_fp16_formats); i++)
1452         {
1453           if (streq (all_fp16_formats[i].name, target_fp16_format_name))
1454             {
1455               arm_fp16_format = all_fp16_formats[i].fp16_format_type;
1456               break;
1457             }
1458         }
1459       if (i == ARRAY_SIZE (all_fp16_formats))
1460         error ("invalid __fp16 format option: -mfp16-format=%s",
1461                target_fp16_format_name);
1462     }
1463   else
1464     arm_fp16_format = ARM_FP16_FORMAT_NONE;
1465
1466   if (target_abi_name)
1467     {
1468       for (i = 0; i < ARRAY_SIZE (arm_all_abis); i++)
1469         {
1470           if (streq (arm_all_abis[i].name, target_abi_name))
1471             {
1472               arm_abi = arm_all_abis[i].abi_type;
1473               break;
1474             }
1475         }
1476       if (i == ARRAY_SIZE (arm_all_abis))
1477         error ("invalid ABI option: -mabi=%s", target_abi_name);
1478     }
1479   else
1480     arm_abi = ARM_DEFAULT_ABI;
1481
1482   /* Make sure that the processor choice does not conflict with any of the
1483      other command line choices.  */
1484   if (TARGET_ARM && !(insn_flags & FL_NOTM))
1485     error ("target CPU does not support ARM mode");
1486
1487   /* BPABI targets use linker tricks to allow interworking on cores
1488      without thumb support.  */
1489   if (TARGET_INTERWORK && !((insn_flags & FL_THUMB) || TARGET_BPABI))
1490     {
1491       warning (0, "target CPU does not support interworking" );
1492       target_flags &= ~MASK_INTERWORK;
1493     }
1494
1495   if (TARGET_THUMB && !(insn_flags & FL_THUMB))
1496     {
1497       warning (0, "target CPU does not support THUMB instructions");
1498       target_flags &= ~MASK_THUMB;
1499     }
1500
1501   if (TARGET_APCS_FRAME && TARGET_THUMB)
1502     {
1503       /* warning (0, "ignoring -mapcs-frame because -mthumb was used"); */
1504       target_flags &= ~MASK_APCS_FRAME;
1505     }
1506
1507   /* Callee super interworking implies thumb interworking.  Adding
1508      this to the flags here simplifies the logic elsewhere.  */
1509   if (TARGET_THUMB && TARGET_CALLEE_INTERWORKING)
1510       target_flags |= MASK_INTERWORK;
1511
1512   /* TARGET_BACKTRACE calls leaf_function_p, which causes a crash if done
1513      from here where no function is being compiled currently.  */
1514   if ((TARGET_TPCS_FRAME || TARGET_TPCS_LEAF_FRAME) && TARGET_ARM)
1515     warning (0, "enabling backtrace support is only meaningful when compiling for the Thumb");
1516
1517   if (TARGET_ARM && TARGET_CALLEE_INTERWORKING)
1518     warning (0, "enabling callee interworking support is only meaningful when compiling for the Thumb");
1519
1520   if (TARGET_ARM && TARGET_CALLER_INTERWORKING)
1521     warning (0, "enabling caller interworking support is only meaningful when compiling for the Thumb");
1522
1523   if (TARGET_APCS_STACK && !TARGET_APCS_FRAME)
1524     {
1525       warning (0, "-mapcs-stack-check incompatible with -mno-apcs-frame");
1526       target_flags |= MASK_APCS_FRAME;
1527     }
1528
1529   if (TARGET_POKE_FUNCTION_NAME)
1530     target_flags |= MASK_APCS_FRAME;
1531
1532   if (TARGET_APCS_REENT && flag_pic)
1533     error ("-fpic and -mapcs-reent are incompatible");
1534
1535   if (TARGET_APCS_REENT)
1536     warning (0, "APCS reentrant code not supported.  Ignored");
1537
1538   /* If this target is normally configured to use APCS frames, warn if they
1539      are turned off and debugging is turned on.  */
1540   if (TARGET_ARM
1541       && write_symbols != NO_DEBUG
1542       && !TARGET_APCS_FRAME
1543       && (TARGET_DEFAULT & MASK_APCS_FRAME))
1544     warning (0, "-g with -mno-apcs-frame may not give sensible debugging");
1545
1546   if (TARGET_APCS_FLOAT)
1547     warning (0, "passing floating point arguments in fp regs not yet supported");
1548
1549   /* Initialize boolean versions of the flags, for use in the arm.md file.  */
1550   arm_arch3m = (insn_flags & FL_ARCH3M) != 0;
1551   arm_arch4 = (insn_flags & FL_ARCH4) != 0;
1552   arm_arch4t = arm_arch4 & ((insn_flags & FL_THUMB) != 0);
1553   arm_arch5 = (insn_flags & FL_ARCH5) != 0;
1554   arm_arch5e = (insn_flags & FL_ARCH5E) != 0;
1555   arm_arch6 = (insn_flags & FL_ARCH6) != 0;
1556   arm_arch6k = (insn_flags & FL_ARCH6K) != 0;
1557   arm_arch_notm = (insn_flags & FL_NOTM) != 0;
1558   arm_arch7em = (insn_flags & FL_ARCH7EM) != 0;
1559   arm_arch_thumb2 = (insn_flags & FL_THUMB2) != 0;
1560   arm_arch_xscale = (insn_flags & FL_XSCALE) != 0;
1561   arm_arch_cirrus = (insn_flags & FL_CIRRUS) != 0;
1562
1563   arm_ld_sched = (tune_flags & FL_LDSCHED) != 0;
1564   arm_tune_strongarm = (tune_flags & FL_STRONG) != 0;
1565   thumb_code = (TARGET_ARM == 0);
1566   arm_tune_wbuf = (tune_flags & FL_WBUF) != 0;
1567   arm_tune_xscale = (tune_flags & FL_XSCALE) != 0;
1568   arm_arch_iwmmxt = (insn_flags & FL_IWMMXT) != 0;
1569   arm_arch_hwdiv = (insn_flags & FL_DIV) != 0;
1570   arm_tune_cortex_a9 = (arm_tune == cortexa9) != 0;
1571
1572   /* If we are not using the default (ARM mode) section anchor offset
1573      ranges, then set the correct ranges now.  */
1574   if (TARGET_THUMB1)
1575     {
1576       /* Thumb-1 LDR instructions cannot have negative offsets.
1577          Permissible positive offset ranges are 5-bit (for byte loads),
1578          6-bit (for halfword loads), or 7-bit (for word loads).
1579          Empirical results suggest a 7-bit anchor range gives the best
1580          overall code size.  */
1581       targetm.min_anchor_offset = 0;
1582       targetm.max_anchor_offset = 127;
1583     }
1584   else if (TARGET_THUMB2)
1585     {
1586       /* The minimum is set such that the total size of the block
1587          for a particular anchor is 248 + 1 + 4095 bytes, which is
1588          divisible by eight, ensuring natural spacing of anchors.  */
1589       targetm.min_anchor_offset = -248;
1590       targetm.max_anchor_offset = 4095;
1591     }
1592
1593   /* V5 code we generate is completely interworking capable, so we turn off
1594      TARGET_INTERWORK here to avoid many tests later on.  */
1595
1596   /* XXX However, we must pass the right pre-processor defines to CPP
1597      or GLD can get confused.  This is a hack.  */
1598   if (TARGET_INTERWORK)
1599     arm_cpp_interwork = 1;
1600
1601   if (arm_arch5)
1602     target_flags &= ~MASK_INTERWORK;
1603
1604   if (TARGET_IWMMXT && !ARM_DOUBLEWORD_ALIGN)
1605     error ("iwmmxt requires an AAPCS compatible ABI for proper operation");
1606
1607   if (TARGET_IWMMXT_ABI && !TARGET_IWMMXT)
1608     error ("iwmmxt abi requires an iwmmxt capable cpu");
1609
1610   if (target_fpu_name == NULL && target_fpe_name != NULL)
1611     {
1612       if (streq (target_fpe_name, "2"))
1613         target_fpu_name = "fpe2";
1614       else if (streq (target_fpe_name, "3"))
1615         target_fpu_name = "fpe3";
1616       else
1617         error ("invalid floating point emulation option: -mfpe=%s",
1618                target_fpe_name);
1619     }
1620
1621   if (target_fpu_name == NULL)
1622     {
1623 #ifdef FPUTYPE_DEFAULT
1624       target_fpu_name = FPUTYPE_DEFAULT;
1625 #else
1626       if (arm_arch_cirrus)
1627         target_fpu_name = "maverick";
1628       else
1629         target_fpu_name = "fpe2";
1630 #endif
1631     }
1632
1633   arm_fpu_desc = NULL;
1634   for (i = 0; i < ARRAY_SIZE (all_fpus); i++)
1635     {
1636       if (streq (all_fpus[i].name, target_fpu_name))
1637         {
1638           arm_fpu_desc = &all_fpus[i];
1639           break;
1640         }
1641     }
1642
1643   if (!arm_fpu_desc)
1644     {
1645       error ("invalid floating point option: -mfpu=%s", target_fpu_name);
1646       return;
1647     }
1648
1649   switch (arm_fpu_desc->model)
1650     {
1651     case ARM_FP_MODEL_FPA:
1652       if (arm_fpu_desc->rev == 2)
1653         arm_fpu_attr = FPU_FPE2;
1654       else if (arm_fpu_desc->rev == 3)
1655         arm_fpu_attr = FPU_FPE3;
1656       else
1657         arm_fpu_attr = FPU_FPA;
1658       break;
1659
1660     case ARM_FP_MODEL_MAVERICK:
1661       arm_fpu_attr = FPU_MAVERICK;
1662       break;
1663
1664     case ARM_FP_MODEL_VFP:
1665       arm_fpu_attr = FPU_VFP;
1666       break;
1667
1668     default:
1669       gcc_unreachable();
1670     }
1671
1672   if (target_float_abi_name != NULL)
1673     {
1674       /* The user specified a FP ABI.  */
1675       for (i = 0; i < ARRAY_SIZE (all_float_abis); i++)
1676         {
1677           if (streq (all_float_abis[i].name, target_float_abi_name))
1678             {
1679               arm_float_abi = all_float_abis[i].abi_type;
1680               break;
1681             }
1682         }
1683       if (i == ARRAY_SIZE (all_float_abis))
1684         error ("invalid floating point abi: -mfloat-abi=%s",
1685                target_float_abi_name);
1686     }
1687   else
1688     arm_float_abi = TARGET_DEFAULT_FLOAT_ABI;
1689
1690   if (TARGET_AAPCS_BASED
1691       && (arm_fpu_desc->model == ARM_FP_MODEL_FPA))
1692     error ("FPA is unsupported in the AAPCS");
1693
1694   if (TARGET_AAPCS_BASED)
1695     {
1696       if (TARGET_CALLER_INTERWORKING)
1697         error ("AAPCS does not support -mcaller-super-interworking");
1698       else
1699         if (TARGET_CALLEE_INTERWORKING)
1700           error ("AAPCS does not support -mcallee-super-interworking");
1701     }
1702
1703   /* FPA and iWMMXt are incompatible because the insn encodings overlap.
1704      VFP and iWMMXt can theoretically coexist, but it's unlikely such silicon
1705      will ever exist.  GCC makes no attempt to support this combination.  */
1706   if (TARGET_IWMMXT && !TARGET_SOFT_FLOAT)
1707     sorry ("iWMMXt and hardware floating point");
1708
1709   /* ??? iWMMXt insn patterns need auditing for Thumb-2.  */
1710   if (TARGET_THUMB2 && TARGET_IWMMXT)
1711     sorry ("Thumb-2 iWMMXt");
1712
1713   /* __fp16 support currently assumes the core has ldrh.  */
1714   if (!arm_arch4 && arm_fp16_format != ARM_FP16_FORMAT_NONE)
1715     sorry ("__fp16 and no ldrh");
1716
1717   /* If soft-float is specified then don't use FPU.  */
1718   if (TARGET_SOFT_FLOAT)
1719     arm_fpu_attr = FPU_NONE;
1720
1721   if (TARGET_AAPCS_BASED)
1722     {
1723       if (arm_abi == ARM_ABI_IWMMXT)
1724         arm_pcs_default = ARM_PCS_AAPCS_IWMMXT;
1725       else if (arm_float_abi == ARM_FLOAT_ABI_HARD
1726                && TARGET_HARD_FLOAT
1727                && TARGET_VFP)
1728         arm_pcs_default = ARM_PCS_AAPCS_VFP;
1729       else
1730         arm_pcs_default = ARM_PCS_AAPCS;
1731     }
1732   else
1733     {
1734       if (arm_float_abi == ARM_FLOAT_ABI_HARD && TARGET_VFP)
1735         sorry ("-mfloat-abi=hard and VFP");
1736
1737       if (arm_abi == ARM_ABI_APCS)
1738         arm_pcs_default = ARM_PCS_APCS;
1739       else
1740         arm_pcs_default = ARM_PCS_ATPCS;
1741     }
1742
1743   /* For arm2/3 there is no need to do any scheduling if there is only
1744      a floating point emulator, or we are doing software floating-point.  */
1745   if ((TARGET_SOFT_FLOAT
1746        || (TARGET_FPA && arm_fpu_desc->rev))
1747       && (tune_flags & FL_MODE32) == 0)
1748     flag_schedule_insns = flag_schedule_insns_after_reload = 0;
1749
1750   if (target_thread_switch)
1751     {
1752       if (strcmp (target_thread_switch, "soft") == 0)
1753         target_thread_pointer = TP_SOFT;
1754       else if (strcmp (target_thread_switch, "auto") == 0)
1755         target_thread_pointer = TP_AUTO;
1756       else if (strcmp (target_thread_switch, "cp15") == 0)
1757         target_thread_pointer = TP_CP15;
1758       else
1759         error ("invalid thread pointer option: -mtp=%s", target_thread_switch);
1760     }
1761
1762   /* Use the cp15 method if it is available.  */
1763   if (target_thread_pointer == TP_AUTO)
1764     {
1765       if (arm_arch6k && !TARGET_THUMB1)
1766         target_thread_pointer = TP_CP15;
1767       else
1768         target_thread_pointer = TP_SOFT;
1769     }
1770
1771   if (TARGET_HARD_TP && TARGET_THUMB1)
1772     error ("can not use -mtp=cp15 with 16-bit Thumb");
1773
1774   /* Override the default structure alignment for AAPCS ABI.  */
1775   if (TARGET_AAPCS_BASED)
1776     arm_structure_size_boundary = 8;
1777
1778   if (structure_size_string != NULL)
1779     {
1780       int size = strtol (structure_size_string, NULL, 0);
1781
1782       if (size == 8 || size == 32
1783           || (ARM_DOUBLEWORD_ALIGN && size == 64))
1784         arm_structure_size_boundary = size;
1785       else
1786         warning (0, "structure size boundary can only be set to %s",
1787                  ARM_DOUBLEWORD_ALIGN ? "8, 32 or 64": "8 or 32");
1788     }
1789
1790   if (!TARGET_ARM && TARGET_VXWORKS_RTP && flag_pic)
1791     {
1792       error ("RTP PIC is incompatible with Thumb");
1793       flag_pic = 0;
1794     }
1795
1796   /* If stack checking is disabled, we can use r10 as the PIC register,
1797      which keeps r9 available.  The EABI specifies r9 as the PIC register.  */
1798   if (flag_pic && TARGET_SINGLE_PIC_BASE)
1799     {
1800       if (TARGET_VXWORKS_RTP)
1801         warning (0, "RTP PIC is incompatible with -msingle-pic-base");
1802       arm_pic_register = (TARGET_APCS_STACK || TARGET_AAPCS_BASED) ? 9 : 10;
1803     }
1804
1805   if (flag_pic && TARGET_VXWORKS_RTP)
1806     arm_pic_register = 9;
1807
1808   if (arm_pic_register_string != NULL)
1809     {
1810       int pic_register = decode_reg_name (arm_pic_register_string);
1811
1812       if (!flag_pic)
1813         warning (0, "-mpic-register= is useless without -fpic");
1814
1815       /* Prevent the user from choosing an obviously stupid PIC register.  */
1816       else if (pic_register < 0 || call_used_regs[pic_register]
1817                || pic_register == HARD_FRAME_POINTER_REGNUM
1818                || pic_register == STACK_POINTER_REGNUM
1819                || pic_register >= PC_REGNUM
1820                || (TARGET_VXWORKS_RTP
1821                    && (unsigned int) pic_register != arm_pic_register))
1822         error ("unable to use '%s' for PIC register", arm_pic_register_string);
1823       else
1824         arm_pic_register = pic_register;
1825     }
1826
1827   /* Enable -mfix-cortex-m3-ldrd by default for Cortex-M3 cores.  */
1828   if (fix_cm3_ldrd == 2)
1829     {
1830       if (selected_cpu == cortexm3)
1831         fix_cm3_ldrd = 1;
1832       else
1833         fix_cm3_ldrd = 0;
1834     }
1835
1836   if (TARGET_THUMB1 && flag_schedule_insns)
1837     {
1838       /* Don't warn since it's on by default in -O2.  */
1839       flag_schedule_insns = 0;
1840     }
1841
1842   if (optimize_size)
1843     {
1844       arm_constant_limit = 1;
1845
1846       /* If optimizing for size, bump the number of instructions that we
1847          are prepared to conditionally execute (even on a StrongARM).  */
1848       max_insns_skipped = 6;
1849     }
1850   else
1851     {
1852       /* For processors with load scheduling, it never costs more than
1853          2 cycles to load a constant, and the load scheduler may well
1854          reduce that to 1.  */
1855       if (arm_ld_sched)
1856         arm_constant_limit = 1;
1857
1858       /* On XScale the longer latency of a load makes it more difficult
1859          to achieve a good schedule, so it's faster to synthesize
1860          constants that can be done in two insns.  */
1861       if (arm_tune_xscale)
1862         arm_constant_limit = 2;
1863
1864       /* StrongARM has early execution of branches, so a sequence
1865          that is worth skipping is shorter.  */
1866       if (arm_tune_strongarm)
1867         max_insns_skipped = 3;
1868     }
1869
1870   /* Hot/Cold partitioning is not currently supported, since we can't
1871      handle literal pool placement in that case.  */
1872   if (flag_reorder_blocks_and_partition)
1873     {
1874       inform (input_location,
1875               "-freorder-blocks-and-partition not supported on this architecture");
1876       flag_reorder_blocks_and_partition = 0;
1877       flag_reorder_blocks = 1;
1878     }
1879
1880   /* Register global variables with the garbage collector.  */
1881   arm_add_gc_roots ();
1882 }
1883
1884 static void
1885 arm_add_gc_roots (void)
1886 {
1887   gcc_obstack_init(&minipool_obstack);
1888   minipool_startobj = (char *) obstack_alloc (&minipool_obstack, 0);
1889 }
1890 \f
1891 /* A table of known ARM exception types.
1892    For use with the interrupt function attribute.  */
1893
1894 typedef struct
1895 {
1896   const char *const arg;
1897   const unsigned long return_value;
1898 }
1899 isr_attribute_arg;
1900
1901 static const isr_attribute_arg isr_attribute_args [] =
1902 {
1903   { "IRQ",   ARM_FT_ISR },
1904   { "irq",   ARM_FT_ISR },
1905   { "FIQ",   ARM_FT_FIQ },
1906   { "fiq",   ARM_FT_FIQ },
1907   { "ABORT", ARM_FT_ISR },
1908   { "abort", ARM_FT_ISR },
1909   { "ABORT", ARM_FT_ISR },
1910   { "abort", ARM_FT_ISR },
1911   { "UNDEF", ARM_FT_EXCEPTION },
1912   { "undef", ARM_FT_EXCEPTION },
1913   { "SWI",   ARM_FT_EXCEPTION },
1914   { "swi",   ARM_FT_EXCEPTION },
1915   { NULL,    ARM_FT_NORMAL }
1916 };
1917
1918 /* Returns the (interrupt) function type of the current
1919    function, or ARM_FT_UNKNOWN if the type cannot be determined.  */
1920
1921 static unsigned long
1922 arm_isr_value (tree argument)
1923 {
1924   const isr_attribute_arg * ptr;
1925   const char *              arg;
1926
1927   if (!arm_arch_notm)
1928     return ARM_FT_NORMAL | ARM_FT_STACKALIGN;
1929
1930   /* No argument - default to IRQ.  */
1931   if (argument == NULL_TREE)
1932     return ARM_FT_ISR;
1933
1934   /* Get the value of the argument.  */
1935   if (TREE_VALUE (argument) == NULL_TREE
1936       || TREE_CODE (TREE_VALUE (argument)) != STRING_CST)
1937     return ARM_FT_UNKNOWN;
1938
1939   arg = TREE_STRING_POINTER (TREE_VALUE (argument));
1940
1941   /* Check it against the list of known arguments.  */
1942   for (ptr = isr_attribute_args; ptr->arg != NULL; ptr++)
1943     if (streq (arg, ptr->arg))
1944       return ptr->return_value;
1945
1946   /* An unrecognized interrupt type.  */
1947   return ARM_FT_UNKNOWN;
1948 }
1949
1950 /* Computes the type of the current function.  */
1951
1952 static unsigned long
1953 arm_compute_func_type (void)
1954 {
1955   unsigned long type = ARM_FT_UNKNOWN;
1956   tree a;
1957   tree attr;
1958
1959   gcc_assert (TREE_CODE (current_function_decl) == FUNCTION_DECL);
1960
1961   /* Decide if the current function is volatile.  Such functions
1962      never return, and many memory cycles can be saved by not storing
1963      register values that will never be needed again.  This optimization
1964      was added to speed up context switching in a kernel application.  */
1965   if (optimize > 0
1966       && (TREE_NOTHROW (current_function_decl)
1967           || !(flag_unwind_tables
1968                || (flag_exceptions && !USING_SJLJ_EXCEPTIONS)))
1969       && TREE_THIS_VOLATILE (current_function_decl))
1970     type |= ARM_FT_VOLATILE;
1971
1972   if (cfun->static_chain_decl != NULL)
1973     type |= ARM_FT_NESTED;
1974
1975   attr = DECL_ATTRIBUTES (current_function_decl);
1976
1977   a = lookup_attribute ("naked", attr);
1978   if (a != NULL_TREE)
1979     type |= ARM_FT_NAKED;
1980
1981   a = lookup_attribute ("isr", attr);
1982   if (a == NULL_TREE)
1983     a = lookup_attribute ("interrupt", attr);
1984
1985   if (a == NULL_TREE)
1986     type |= TARGET_INTERWORK ? ARM_FT_INTERWORKED : ARM_FT_NORMAL;
1987   else
1988     type |= arm_isr_value (TREE_VALUE (a));
1989
1990   return type;
1991 }
1992
1993 /* Returns the type of the current function.  */
1994
1995 unsigned long
1996 arm_current_func_type (void)
1997 {
1998   if (ARM_FUNC_TYPE (cfun->machine->func_type) == ARM_FT_UNKNOWN)
1999     cfun->machine->func_type = arm_compute_func_type ();
2000
2001   return cfun->machine->func_type;
2002 }
2003
2004 bool
2005 arm_allocate_stack_slots_for_args (void)
2006 {
2007   /* Naked functions should not allocate stack slots for arguments.  */
2008   return !IS_NAKED (arm_current_func_type ());
2009 }
2010
2011 \f
2012 /* Output assembler code for a block containing the constant parts
2013    of a trampoline, leaving space for the variable parts.
2014
2015    On the ARM, (if r8 is the static chain regnum, and remembering that
2016    referencing pc adds an offset of 8) the trampoline looks like:
2017            ldr          r8, [pc, #0]
2018            ldr          pc, [pc]
2019            .word        static chain value
2020            .word        function's address
2021    XXX FIXME: When the trampoline returns, r8 will be clobbered.  */
2022
2023 static void
2024 arm_asm_trampoline_template (FILE *f)
2025 {
2026   if (TARGET_ARM)
2027     {
2028       asm_fprintf (f, "\tldr\t%r, [%r, #0]\n", STATIC_CHAIN_REGNUM, PC_REGNUM);
2029       asm_fprintf (f, "\tldr\t%r, [%r, #0]\n", PC_REGNUM, PC_REGNUM);
2030     }
2031   else if (TARGET_THUMB2)
2032     {
2033       /* The Thumb-2 trampoline is similar to the arm implementation.
2034          Unlike 16-bit Thumb, we enter the stub in thumb mode.  */
2035       asm_fprintf (f, "\tldr.w\t%r, [%r, #4]\n",
2036                    STATIC_CHAIN_REGNUM, PC_REGNUM);
2037       asm_fprintf (f, "\tldr.w\t%r, [%r, #4]\n", PC_REGNUM, PC_REGNUM);
2038     }
2039   else
2040     {
2041       ASM_OUTPUT_ALIGN (f, 2);
2042       fprintf (f, "\t.code\t16\n");
2043       fprintf (f, ".Ltrampoline_start:\n");
2044       asm_fprintf (f, "\tpush\t{r0, r1}\n");
2045       asm_fprintf (f, "\tldr\tr0, [%r, #8]\n", PC_REGNUM);
2046       asm_fprintf (f, "\tmov\t%r, r0\n", STATIC_CHAIN_REGNUM);
2047       asm_fprintf (f, "\tldr\tr0, [%r, #8]\n", PC_REGNUM);
2048       asm_fprintf (f, "\tstr\tr0, [%r, #4]\n", SP_REGNUM);
2049       asm_fprintf (f, "\tpop\t{r0, %r}\n", PC_REGNUM);
2050     }
2051   assemble_aligned_integer (UNITS_PER_WORD, const0_rtx);
2052   assemble_aligned_integer (UNITS_PER_WORD, const0_rtx);
2053 }
2054
2055 /* Emit RTL insns to initialize the variable parts of a trampoline.  */
2056
2057 static void
2058 arm_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
2059 {
2060   rtx fnaddr, mem, a_tramp;
2061
2062   emit_block_move (m_tramp, assemble_trampoline_template (),
2063                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
2064
2065   mem = adjust_address (m_tramp, SImode, TARGET_32BIT ? 8 : 12);
2066   emit_move_insn (mem, chain_value);
2067
2068   mem = adjust_address (m_tramp, SImode, TARGET_32BIT ? 12 : 16);
2069   fnaddr = XEXP (DECL_RTL (fndecl), 0);
2070   emit_move_insn (mem, fnaddr);
2071
2072   a_tramp = XEXP (m_tramp, 0);
2073   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__clear_cache"),
2074                      LCT_NORMAL, VOIDmode, 2, a_tramp, Pmode,
2075                      plus_constant (a_tramp, TRAMPOLINE_SIZE), Pmode);
2076 }
2077
2078 /* Thumb trampolines should be entered in thumb mode, so set
2079    the bottom bit of the address.  */
2080
2081 static rtx
2082 arm_trampoline_adjust_address (rtx addr)
2083 {
2084   if (TARGET_THUMB)
2085     addr = expand_simple_binop (Pmode, IOR, addr, const1_rtx,
2086                                 NULL, 0, OPTAB_LIB_WIDEN);
2087   return addr;
2088 }
2089 \f
2090 /* Return 1 if it is possible to return using a single instruction.
2091    If SIBLING is non-null, this is a test for a return before a sibling
2092    call.  SIBLING is the call insn, so we can examine its register usage.  */
2093
2094 int
2095 use_return_insn (int iscond, rtx sibling)
2096 {
2097   int regno;
2098   unsigned int func_type;
2099   unsigned long saved_int_regs;
2100   unsigned HOST_WIDE_INT stack_adjust;
2101   arm_stack_offsets *offsets;
2102
2103   /* Never use a return instruction before reload has run.  */
2104   if (!reload_completed)
2105     return 0;
2106
2107   func_type = arm_current_func_type ();
2108
2109   /* Naked, volatile and stack alignment functions need special
2110      consideration.  */
2111   if (func_type & (ARM_FT_VOLATILE | ARM_FT_NAKED | ARM_FT_STACKALIGN))
2112     return 0;
2113
2114   /* So do interrupt functions that use the frame pointer and Thumb
2115      interrupt functions.  */
2116   if (IS_INTERRUPT (func_type) && (frame_pointer_needed || TARGET_THUMB))
2117     return 0;
2118
2119   offsets = arm_get_frame_offsets ();
2120   stack_adjust = offsets->outgoing_args - offsets->saved_regs;
2121
2122   /* As do variadic functions.  */
2123   if (crtl->args.pretend_args_size
2124       || cfun->machine->uses_anonymous_args
2125       /* Or if the function calls __builtin_eh_return () */
2126       || crtl->calls_eh_return
2127       /* Or if the function calls alloca */
2128       || cfun->calls_alloca
2129       /* Or if there is a stack adjustment.  However, if the stack pointer
2130          is saved on the stack, we can use a pre-incrementing stack load.  */
2131       || !(stack_adjust == 0 || (TARGET_APCS_FRAME && frame_pointer_needed
2132                                  && stack_adjust == 4)))
2133     return 0;
2134
2135   saved_int_regs = offsets->saved_regs_mask;
2136
2137   /* Unfortunately, the insn
2138
2139        ldmib sp, {..., sp, ...}
2140
2141      triggers a bug on most SA-110 based devices, such that the stack
2142      pointer won't be correctly restored if the instruction takes a
2143      page fault.  We work around this problem by popping r3 along with
2144      the other registers, since that is never slower than executing
2145      another instruction.
2146
2147      We test for !arm_arch5 here, because code for any architecture
2148      less than this could potentially be run on one of the buggy
2149      chips.  */
2150   if (stack_adjust == 4 && !arm_arch5 && TARGET_ARM)
2151     {
2152       /* Validate that r3 is a call-clobbered register (always true in
2153          the default abi) ...  */
2154       if (!call_used_regs[3])
2155         return 0;
2156
2157       /* ... that it isn't being used for a return value ... */
2158       if (arm_size_return_regs () >= (4 * UNITS_PER_WORD))
2159         return 0;
2160
2161       /* ... or for a tail-call argument ...  */
2162       if (sibling)
2163         {
2164           gcc_assert (GET_CODE (sibling) == CALL_INSN);
2165
2166           if (find_regno_fusage (sibling, USE, 3))
2167             return 0;
2168         }
2169
2170       /* ... and that there are no call-saved registers in r0-r2
2171          (always true in the default ABI).  */
2172       if (saved_int_regs & 0x7)
2173         return 0;
2174     }
2175
2176   /* Can't be done if interworking with Thumb, and any registers have been
2177      stacked.  */
2178   if (TARGET_INTERWORK && saved_int_regs != 0 && !IS_INTERRUPT(func_type))
2179     return 0;
2180
2181   /* On StrongARM, conditional returns are expensive if they aren't
2182      taken and multiple registers have been stacked.  */
2183   if (iscond && arm_tune_strongarm)
2184     {
2185       /* Conditional return when just the LR is stored is a simple
2186          conditional-load instruction, that's not expensive.  */
2187       if (saved_int_regs != 0 && saved_int_regs != (1 << LR_REGNUM))
2188         return 0;
2189
2190       if (flag_pic 
2191           && arm_pic_register != INVALID_REGNUM
2192           && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM))
2193         return 0;
2194     }
2195
2196   /* If there are saved registers but the LR isn't saved, then we need
2197      two instructions for the return.  */
2198   if (saved_int_regs && !(saved_int_regs & (1 << LR_REGNUM)))
2199     return 0;
2200
2201   /* Can't be done if any of the FPA regs are pushed,
2202      since this also requires an insn.  */
2203   if (TARGET_HARD_FLOAT && TARGET_FPA)
2204     for (regno = FIRST_FPA_REGNUM; regno <= LAST_FPA_REGNUM; regno++)
2205       if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
2206         return 0;
2207
2208   /* Likewise VFP regs.  */
2209   if (TARGET_HARD_FLOAT && TARGET_VFP)
2210     for (regno = FIRST_VFP_REGNUM; regno <= LAST_VFP_REGNUM; regno++)
2211       if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
2212         return 0;
2213
2214   if (TARGET_REALLY_IWMMXT)
2215     for (regno = FIRST_IWMMXT_REGNUM; regno <= LAST_IWMMXT_REGNUM; regno++)
2216       if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
2217         return 0;
2218
2219   return 1;
2220 }
2221
2222 /* Return TRUE if int I is a valid immediate ARM constant.  */
2223
2224 int
2225 const_ok_for_arm (HOST_WIDE_INT i)
2226 {
2227   int lowbit;
2228
2229   /* For machines with >32 bit HOST_WIDE_INT, the bits above bit 31 must
2230      be all zero, or all one.  */
2231   if ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff) != 0
2232       && ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff)
2233           != ((~(unsigned HOST_WIDE_INT) 0)
2234               & ~(unsigned HOST_WIDE_INT) 0xffffffff)))
2235     return FALSE;
2236
2237   i &= (unsigned HOST_WIDE_INT) 0xffffffff;
2238
2239   /* Fast return for 0 and small values.  We must do this for zero, since
2240      the code below can't handle that one case.  */
2241   if ((i & ~(unsigned HOST_WIDE_INT) 0xff) == 0)
2242     return TRUE;
2243
2244   /* Get the number of trailing zeros.  */
2245   lowbit = ffs((int) i) - 1;
2246   
2247   /* Only even shifts are allowed in ARM mode so round down to the
2248      nearest even number.  */
2249   if (TARGET_ARM)
2250     lowbit &= ~1;
2251
2252   if ((i & ~(((unsigned HOST_WIDE_INT) 0xff) << lowbit)) == 0)
2253     return TRUE;
2254
2255   if (TARGET_ARM)
2256     {
2257       /* Allow rotated constants in ARM mode.  */
2258       if (lowbit <= 4
2259            && ((i & ~0xc000003f) == 0
2260                || (i & ~0xf000000f) == 0
2261                || (i & ~0xfc000003) == 0))
2262         return TRUE;
2263     }
2264   else
2265     {
2266       HOST_WIDE_INT v;
2267
2268       /* Allow repeated pattern.  */
2269       v = i & 0xff;
2270       v |= v << 16;
2271       if (i == v || i == (v | (v << 8)))
2272         return TRUE;
2273     }
2274
2275   return FALSE;
2276 }
2277
2278 /* Return true if I is a valid constant for the operation CODE.  */
2279 static int
2280 const_ok_for_op (HOST_WIDE_INT i, enum rtx_code code)
2281 {
2282   if (const_ok_for_arm (i))
2283     return 1;
2284
2285   switch (code)
2286     {
2287     case PLUS:
2288     case COMPARE:
2289     case EQ:
2290     case NE:
2291     case GT:
2292     case LE:
2293     case LT:
2294     case GE:
2295     case GEU:
2296     case LTU:
2297     case GTU:
2298     case LEU:
2299     case UNORDERED:
2300     case ORDERED:
2301     case UNEQ:
2302     case UNGE:
2303     case UNLT:
2304     case UNGT:
2305     case UNLE:
2306       return const_ok_for_arm (ARM_SIGN_EXTEND (-i));
2307
2308     case MINUS:         /* Should only occur with (MINUS I reg) => rsb */
2309     case XOR:
2310       return 0;
2311
2312     case IOR:
2313       if (TARGET_THUMB2)
2314         return const_ok_for_arm (ARM_SIGN_EXTEND (~i));
2315       return 0;
2316
2317     case AND:
2318       return const_ok_for_arm (ARM_SIGN_EXTEND (~i));
2319
2320     default:
2321       gcc_unreachable ();
2322     }
2323 }
2324
2325 /* Emit a sequence of insns to handle a large constant.
2326    CODE is the code of the operation required, it can be any of SET, PLUS,
2327    IOR, AND, XOR, MINUS;
2328    MODE is the mode in which the operation is being performed;
2329    VAL is the integer to operate on;
2330    SOURCE is the other operand (a register, or a null-pointer for SET);
2331    SUBTARGETS means it is safe to create scratch registers if that will
2332    either produce a simpler sequence, or we will want to cse the values.
2333    Return value is the number of insns emitted.  */
2334
2335 /* ??? Tweak this for thumb2.  */
2336 int
2337 arm_split_constant (enum rtx_code code, enum machine_mode mode, rtx insn,
2338                     HOST_WIDE_INT val, rtx target, rtx source, int subtargets)
2339 {
2340   rtx cond;
2341
2342   if (insn && GET_CODE (PATTERN (insn)) == COND_EXEC)
2343     cond = COND_EXEC_TEST (PATTERN (insn));
2344   else
2345     cond = NULL_RTX;
2346
2347   if (subtargets || code == SET
2348       || (GET_CODE (target) == REG && GET_CODE (source) == REG
2349           && REGNO (target) != REGNO (source)))
2350     {
2351       /* After arm_reorg has been called, we can't fix up expensive
2352          constants by pushing them into memory so we must synthesize
2353          them in-line, regardless of the cost.  This is only likely to
2354          be more costly on chips that have load delay slots and we are
2355          compiling without running the scheduler (so no splitting
2356          occurred before the final instruction emission).
2357
2358          Ref: gcc -O1 -mcpu=strongarm gcc.c-torture/compile/980506-2.c
2359       */
2360       if (!after_arm_reorg
2361           && !cond
2362           && (arm_gen_constant (code, mode, NULL_RTX, val, target, source,
2363                                 1, 0)
2364               > arm_constant_limit + (code != SET)))
2365         {
2366           if (code == SET)
2367             {
2368               /* Currently SET is the only monadic value for CODE, all
2369                  the rest are diadic.  */
2370               if (TARGET_USE_MOVT)
2371                 arm_emit_movpair (target, GEN_INT (val));
2372               else
2373                 emit_set_insn (target, GEN_INT (val));
2374
2375               return 1;
2376             }
2377           else
2378             {
2379               rtx temp = subtargets ? gen_reg_rtx (mode) : target;
2380
2381               if (TARGET_USE_MOVT)
2382                 arm_emit_movpair (temp, GEN_INT (val));
2383               else
2384                 emit_set_insn (temp, GEN_INT (val));
2385
2386               /* For MINUS, the value is subtracted from, since we never
2387                  have subtraction of a constant.  */
2388               if (code == MINUS)
2389                 emit_set_insn (target, gen_rtx_MINUS (mode, temp, source));
2390               else
2391                 emit_set_insn (target,
2392                                gen_rtx_fmt_ee (code, mode, source, temp));
2393               return 2;
2394             }
2395         }
2396     }
2397
2398   return arm_gen_constant (code, mode, cond, val, target, source, subtargets,
2399                            1);
2400 }
2401
2402 /* Return the number of instructions required to synthesize the given
2403    constant, if we start emitting them from bit-position I.  */
2404 static int
2405 count_insns_for_constant (HOST_WIDE_INT remainder, int i)
2406 {
2407   HOST_WIDE_INT temp1;
2408   int step_size = TARGET_ARM ? 2 : 1;
2409   int num_insns = 0;
2410
2411   gcc_assert (TARGET_ARM || i == 0);
2412
2413   do
2414     {
2415       int end;
2416
2417       if (i <= 0)
2418         i += 32;
2419       if (remainder & (((1 << step_size) - 1) << (i - step_size)))
2420         {
2421           end = i - 8;
2422           if (end < 0)
2423             end += 32;
2424           temp1 = remainder & ((0x0ff << end)
2425                                     | ((i < end) ? (0xff >> (32 - end)) : 0));
2426           remainder &= ~temp1;
2427           num_insns++;
2428           i -= 8 - step_size;
2429         }
2430       i -= step_size;
2431     } while (remainder);
2432   return num_insns;
2433 }
2434
2435 static int
2436 find_best_start (unsigned HOST_WIDE_INT remainder)
2437 {
2438   int best_consecutive_zeros = 0;
2439   int i;
2440   int best_start = 0;
2441
2442   /* If we aren't targetting ARM, the best place to start is always at
2443      the bottom.  */
2444   if (! TARGET_ARM)
2445     return 0;
2446
2447   for (i = 0; i < 32; i += 2)
2448     {
2449       int consecutive_zeros = 0;
2450
2451       if (!(remainder & (3 << i)))
2452         {
2453           while ((i < 32) && !(remainder & (3 << i)))
2454             {
2455               consecutive_zeros += 2;
2456               i += 2;
2457             }
2458           if (consecutive_zeros > best_consecutive_zeros)
2459             {
2460               best_consecutive_zeros = consecutive_zeros;
2461               best_start = i - consecutive_zeros;
2462             }
2463           i -= 2;
2464         }
2465     }
2466
2467   /* So long as it won't require any more insns to do so, it's
2468      desirable to emit a small constant (in bits 0...9) in the last
2469      insn.  This way there is more chance that it can be combined with
2470      a later addressing insn to form a pre-indexed load or store
2471      operation.  Consider:
2472
2473            *((volatile int *)0xe0000100) = 1;
2474            *((volatile int *)0xe0000110) = 2;
2475
2476      We want this to wind up as:
2477
2478             mov rA, #0xe0000000
2479             mov rB, #1
2480             str rB, [rA, #0x100]
2481             mov rB, #2
2482             str rB, [rA, #0x110]
2483
2484      rather than having to synthesize both large constants from scratch.
2485
2486      Therefore, we calculate how many insns would be required to emit
2487      the constant starting from `best_start', and also starting from
2488      zero (i.e. with bit 31 first to be output).  If `best_start' doesn't
2489      yield a shorter sequence, we may as well use zero.  */
2490   if (best_start != 0
2491       && ((((unsigned HOST_WIDE_INT) 1) << best_start) < remainder)
2492       && (count_insns_for_constant (remainder, 0) <=
2493           count_insns_for_constant (remainder, best_start)))
2494     best_start = 0;
2495
2496   return best_start;
2497 }
2498
2499 /* Emit an instruction with the indicated PATTERN.  If COND is
2500    non-NULL, conditionalize the execution of the instruction on COND
2501    being true.  */
2502
2503 static void
2504 emit_constant_insn (rtx cond, rtx pattern)
2505 {
2506   if (cond)
2507     pattern = gen_rtx_COND_EXEC (VOIDmode, copy_rtx (cond), pattern);
2508   emit_insn (pattern);
2509 }
2510
2511 /* As above, but extra parameter GENERATE which, if clear, suppresses
2512    RTL generation.  */
2513 /* ??? This needs more work for thumb2.  */
2514
2515 static int
2516 arm_gen_constant (enum rtx_code code, enum machine_mode mode, rtx cond,
2517                   HOST_WIDE_INT val, rtx target, rtx source, int subtargets,
2518                   int generate)
2519 {
2520   int can_invert = 0;
2521   int can_negate = 0;
2522   int final_invert = 0;
2523   int can_negate_initial = 0;
2524   int can_shift = 0;
2525   int i;
2526   int num_bits_set = 0;
2527   int set_sign_bit_copies = 0;
2528   int clear_sign_bit_copies = 0;
2529   int clear_zero_bit_copies = 0;
2530   int set_zero_bit_copies = 0;
2531   int insns = 0;
2532   unsigned HOST_WIDE_INT temp1, temp2;
2533   unsigned HOST_WIDE_INT remainder = val & 0xffffffff;
2534   int step_size = TARGET_ARM ? 2 : 1;
2535
2536   /* Find out which operations are safe for a given CODE.  Also do a quick
2537      check for degenerate cases; these can occur when DImode operations
2538      are split.  */
2539   switch (code)
2540     {
2541     case SET:
2542       can_invert = 1;
2543       can_shift = 1;
2544       can_negate = 1;
2545       break;
2546
2547     case PLUS:
2548       can_negate = 1;
2549       can_negate_initial = 1;
2550       break;
2551
2552     case IOR:
2553       if (remainder == 0xffffffff)
2554         {
2555           if (generate)
2556             emit_constant_insn (cond,
2557                                 gen_rtx_SET (VOIDmode, target,
2558                                              GEN_INT (ARM_SIGN_EXTEND (val))));
2559           return 1;
2560         }
2561
2562       if (remainder == 0)
2563         {
2564           if (reload_completed && rtx_equal_p (target, source))
2565             return 0;
2566
2567           if (generate)
2568             emit_constant_insn (cond,
2569                                 gen_rtx_SET (VOIDmode, target, source));
2570           return 1;
2571         }
2572
2573       if (TARGET_THUMB2)
2574         can_invert = 1;
2575       break;
2576
2577     case AND:
2578       if (remainder == 0)
2579         {
2580           if (generate)
2581             emit_constant_insn (cond,
2582                                 gen_rtx_SET (VOIDmode, target, const0_rtx));
2583           return 1;
2584         }
2585       if (remainder == 0xffffffff)
2586         {
2587           if (reload_completed && rtx_equal_p (target, source))
2588             return 0;
2589           if (generate)
2590             emit_constant_insn (cond,
2591                                 gen_rtx_SET (VOIDmode, target, source));
2592           return 1;
2593         }
2594       can_invert = 1;
2595       break;
2596
2597     case XOR:
2598       if (remainder == 0)
2599         {
2600           if (reload_completed && rtx_equal_p (target, source))
2601             return 0;
2602           if (generate)
2603             emit_constant_insn (cond,
2604                                 gen_rtx_SET (VOIDmode, target, source));
2605           return 1;
2606         }
2607
2608       if (remainder == 0xffffffff)
2609         {
2610           if (generate)
2611             emit_constant_insn (cond,
2612                                 gen_rtx_SET (VOIDmode, target,
2613                                              gen_rtx_NOT (mode, source)));
2614           return 1;
2615         }
2616       break;
2617
2618     case MINUS:
2619       /* We treat MINUS as (val - source), since (source - val) is always
2620          passed as (source + (-val)).  */
2621       if (remainder == 0)
2622         {
2623           if (generate)
2624             emit_constant_insn (cond,
2625                                 gen_rtx_SET (VOIDmode, target,
2626                                              gen_rtx_NEG (mode, source)));
2627           return 1;
2628         }
2629       if (const_ok_for_arm (val))
2630         {
2631           if (generate)
2632             emit_constant_insn (cond,
2633                                 gen_rtx_SET (VOIDmode, target,
2634                                              gen_rtx_MINUS (mode, GEN_INT (val),
2635                                                             source)));
2636           return 1;
2637         }
2638       can_negate = 1;
2639
2640       break;
2641
2642     default:
2643       gcc_unreachable ();
2644     }
2645
2646   /* If we can do it in one insn get out quickly.  */
2647   if (const_ok_for_arm (val)
2648       || (can_negate_initial && const_ok_for_arm (-val))
2649       || (can_invert && const_ok_for_arm (~val)))
2650     {
2651       if (generate)
2652         emit_constant_insn (cond,
2653                             gen_rtx_SET (VOIDmode, target,
2654                                          (source
2655                                           ? gen_rtx_fmt_ee (code, mode, source,
2656                                                             GEN_INT (val))
2657                                           : GEN_INT (val))));
2658       return 1;
2659     }
2660
2661   /* Calculate a few attributes that may be useful for specific
2662      optimizations.  */
2663   /* Count number of leading zeros.  */
2664   for (i = 31; i >= 0; i--)
2665     {
2666       if ((remainder & (1 << i)) == 0)
2667         clear_sign_bit_copies++;
2668       else
2669         break;
2670     }
2671
2672   /* Count number of leading 1's.  */
2673   for (i = 31; i >= 0; i--)
2674     {
2675       if ((remainder & (1 << i)) != 0)
2676         set_sign_bit_copies++;
2677       else
2678         break;
2679     }
2680
2681   /* Count number of trailing zero's.  */
2682   for (i = 0; i <= 31; i++)
2683     {
2684       if ((remainder & (1 << i)) == 0)
2685         clear_zero_bit_copies++;
2686       else
2687         break;
2688     }
2689
2690   /* Count number of trailing 1's.  */
2691   for (i = 0; i <= 31; i++)
2692     {
2693       if ((remainder & (1 << i)) != 0)
2694         set_zero_bit_copies++;
2695       else
2696         break;
2697     }
2698
2699   switch (code)
2700     {
2701     case SET:
2702       /* See if we can use movw.  */
2703       if (arm_arch_thumb2 && (remainder & 0xffff0000) == 0)
2704         {
2705           if (generate)
2706             emit_constant_insn (cond, gen_rtx_SET (VOIDmode, target,
2707                                                    GEN_INT (val)));
2708           return 1;
2709         }
2710
2711       /* See if we can do this by sign_extending a constant that is known
2712          to be negative.  This is a good, way of doing it, since the shift
2713          may well merge into a subsequent insn.  */
2714       if (set_sign_bit_copies > 1)
2715         {
2716           if (const_ok_for_arm
2717               (temp1 = ARM_SIGN_EXTEND (remainder
2718                                         << (set_sign_bit_copies - 1))))
2719             {
2720               if (generate)
2721                 {
2722                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2723                   emit_constant_insn (cond,
2724                                       gen_rtx_SET (VOIDmode, new_src,
2725                                                    GEN_INT (temp1)));
2726                   emit_constant_insn (cond,
2727                                       gen_ashrsi3 (target, new_src,
2728                                                    GEN_INT (set_sign_bit_copies - 1)));
2729                 }
2730               return 2;
2731             }
2732           /* For an inverted constant, we will need to set the low bits,
2733              these will be shifted out of harm's way.  */
2734           temp1 |= (1 << (set_sign_bit_copies - 1)) - 1;
2735           if (const_ok_for_arm (~temp1))
2736             {
2737               if (generate)
2738                 {
2739                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2740                   emit_constant_insn (cond,
2741                                       gen_rtx_SET (VOIDmode, new_src,
2742                                                    GEN_INT (temp1)));
2743                   emit_constant_insn (cond,
2744                                       gen_ashrsi3 (target, new_src,
2745                                                    GEN_INT (set_sign_bit_copies - 1)));
2746                 }
2747               return 2;
2748             }
2749         }
2750
2751       /* See if we can calculate the value as the difference between two
2752          valid immediates.  */
2753       if (clear_sign_bit_copies + clear_zero_bit_copies <= 16)
2754         {
2755           int topshift = clear_sign_bit_copies & ~1;
2756
2757           temp1 = ARM_SIGN_EXTEND ((remainder + (0x00800000 >> topshift))
2758                                    & (0xff000000 >> topshift));
2759
2760           /* If temp1 is zero, then that means the 9 most significant
2761              bits of remainder were 1 and we've caused it to overflow.
2762              When topshift is 0 we don't need to do anything since we
2763              can borrow from 'bit 32'.  */
2764           if (temp1 == 0 && topshift != 0)
2765             temp1 = 0x80000000 >> (topshift - 1);
2766
2767           temp2 = ARM_SIGN_EXTEND (temp1 - remainder);
2768
2769           if (const_ok_for_arm (temp2))
2770             {
2771               if (generate)
2772                 {
2773                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2774                   emit_constant_insn (cond,
2775                                       gen_rtx_SET (VOIDmode, new_src,
2776                                                    GEN_INT (temp1)));
2777                   emit_constant_insn (cond,
2778                                       gen_addsi3 (target, new_src,
2779                                                   GEN_INT (-temp2)));
2780                 }
2781
2782               return 2;
2783             }
2784         }
2785
2786       /* See if we can generate this by setting the bottom (or the top)
2787          16 bits, and then shifting these into the other half of the
2788          word.  We only look for the simplest cases, to do more would cost
2789          too much.  Be careful, however, not to generate this when the
2790          alternative would take fewer insns.  */
2791       if (val & 0xffff0000)
2792         {
2793           temp1 = remainder & 0xffff0000;
2794           temp2 = remainder & 0x0000ffff;
2795
2796           /* Overlaps outside this range are best done using other methods.  */
2797           for (i = 9; i < 24; i++)
2798             {
2799               if ((((temp2 | (temp2 << i)) & 0xffffffff) == remainder)
2800                   && !const_ok_for_arm (temp2))
2801                 {
2802                   rtx new_src = (subtargets
2803                                  ? (generate ? gen_reg_rtx (mode) : NULL_RTX)
2804                                  : target);
2805                   insns = arm_gen_constant (code, mode, cond, temp2, new_src,
2806                                             source, subtargets, generate);
2807                   source = new_src;
2808                   if (generate)
2809                     emit_constant_insn
2810                       (cond,
2811                        gen_rtx_SET
2812                        (VOIDmode, target,
2813                         gen_rtx_IOR (mode,
2814                                      gen_rtx_ASHIFT (mode, source,
2815                                                      GEN_INT (i)),
2816                                      source)));
2817                   return insns + 1;
2818                 }
2819             }
2820
2821           /* Don't duplicate cases already considered.  */
2822           for (i = 17; i < 24; i++)
2823             {
2824               if (((temp1 | (temp1 >> i)) == remainder)
2825                   && !const_ok_for_arm (temp1))
2826                 {
2827                   rtx new_src = (subtargets
2828                                  ? (generate ? gen_reg_rtx (mode) : NULL_RTX)
2829                                  : target);
2830                   insns = arm_gen_constant (code, mode, cond, temp1, new_src,
2831                                             source, subtargets, generate);
2832                   source = new_src;
2833                   if (generate)
2834                     emit_constant_insn
2835                       (cond,
2836                        gen_rtx_SET (VOIDmode, target,
2837                                     gen_rtx_IOR
2838                                     (mode,
2839                                      gen_rtx_LSHIFTRT (mode, source,
2840                                                        GEN_INT (i)),
2841                                      source)));
2842                   return insns + 1;
2843                 }
2844             }
2845         }
2846       break;
2847
2848     case IOR:
2849     case XOR:
2850       /* If we have IOR or XOR, and the constant can be loaded in a
2851          single instruction, and we can find a temporary to put it in,
2852          then this can be done in two instructions instead of 3-4.  */
2853       if (subtargets
2854           /* TARGET can't be NULL if SUBTARGETS is 0 */
2855           || (reload_completed && !reg_mentioned_p (target, source)))
2856         {
2857           if (const_ok_for_arm (ARM_SIGN_EXTEND (~val)))
2858             {
2859               if (generate)
2860                 {
2861                   rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2862
2863                   emit_constant_insn (cond,
2864                                       gen_rtx_SET (VOIDmode, sub,
2865                                                    GEN_INT (val)));
2866                   emit_constant_insn (cond,
2867                                       gen_rtx_SET (VOIDmode, target,
2868                                                    gen_rtx_fmt_ee (code, mode,
2869                                                                    source, sub)));
2870                 }
2871               return 2;
2872             }
2873         }
2874
2875       if (code == XOR)
2876         break;
2877
2878       /*  Convert.
2879           x = y | constant ( which is composed of set_sign_bit_copies of leading 1s
2880                              and the remainder 0s for e.g. 0xfff00000)
2881           x = ~(~(y ashift set_sign_bit_copies) lshiftrt set_sign_bit_copies)
2882
2883           This can be done in 2 instructions by using shifts with mov or mvn.
2884           e.g. for
2885           x = x | 0xfff00000;
2886           we generate.
2887           mvn   r0, r0, asl #12
2888           mvn   r0, r0, lsr #12  */
2889       if (set_sign_bit_copies > 8
2890           && (val & (-1 << (32 - set_sign_bit_copies))) == val)
2891         {
2892           if (generate)
2893             {
2894               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2895               rtx shift = GEN_INT (set_sign_bit_copies);
2896
2897               emit_constant_insn
2898                 (cond,
2899                  gen_rtx_SET (VOIDmode, sub,
2900                               gen_rtx_NOT (mode,
2901                                            gen_rtx_ASHIFT (mode,
2902                                                            source,
2903                                                            shift))));
2904               emit_constant_insn
2905                 (cond,
2906                  gen_rtx_SET (VOIDmode, target,
2907                               gen_rtx_NOT (mode,
2908                                            gen_rtx_LSHIFTRT (mode, sub,
2909                                                              shift))));
2910             }
2911           return 2;
2912         }
2913
2914       /* Convert
2915           x = y | constant (which has set_zero_bit_copies number of trailing ones).
2916            to
2917           x = ~((~y lshiftrt set_zero_bit_copies) ashift set_zero_bit_copies).
2918
2919           For eg. r0 = r0 | 0xfff
2920                mvn      r0, r0, lsr #12
2921                mvn      r0, r0, asl #12
2922
2923       */
2924       if (set_zero_bit_copies > 8
2925           && (remainder & ((1 << set_zero_bit_copies) - 1)) == remainder)
2926         {
2927           if (generate)
2928             {
2929               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2930               rtx shift = GEN_INT (set_zero_bit_copies);
2931
2932               emit_constant_insn
2933                 (cond,
2934                  gen_rtx_SET (VOIDmode, sub,
2935                               gen_rtx_NOT (mode,
2936                                            gen_rtx_LSHIFTRT (mode,
2937                                                              source,
2938                                                              shift))));
2939               emit_constant_insn
2940                 (cond,
2941                  gen_rtx_SET (VOIDmode, target,
2942                               gen_rtx_NOT (mode,
2943                                            gen_rtx_ASHIFT (mode, sub,
2944                                                            shift))));
2945             }
2946           return 2;
2947         }
2948
2949       /* This will never be reached for Thumb2 because orn is a valid
2950          instruction. This is for Thumb1 and the ARM 32 bit cases.
2951
2952          x = y | constant (such that ~constant is a valid constant)
2953          Transform this to
2954          x = ~(~y & ~constant).
2955       */
2956       if (const_ok_for_arm (temp1 = ARM_SIGN_EXTEND (~val)))
2957         {
2958           if (generate)
2959             {
2960               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2961               emit_constant_insn (cond,
2962                                   gen_rtx_SET (VOIDmode, sub,
2963                                                gen_rtx_NOT (mode, source)));
2964               source = sub;
2965               if (subtargets)
2966                 sub = gen_reg_rtx (mode);
2967               emit_constant_insn (cond,
2968                                   gen_rtx_SET (VOIDmode, sub,
2969                                                gen_rtx_AND (mode, source,
2970                                                             GEN_INT (temp1))));
2971               emit_constant_insn (cond,
2972                                   gen_rtx_SET (VOIDmode, target,
2973                                                gen_rtx_NOT (mode, sub)));
2974             }
2975           return 3;
2976         }
2977       break;
2978
2979     case AND:
2980       /* See if two shifts will do 2 or more insn's worth of work.  */
2981       if (clear_sign_bit_copies >= 16 && clear_sign_bit_copies < 24)
2982         {
2983           HOST_WIDE_INT shift_mask = ((0xffffffff
2984                                        << (32 - clear_sign_bit_copies))
2985                                       & 0xffffffff);
2986
2987           if ((remainder | shift_mask) != 0xffffffff)
2988             {
2989               if (generate)
2990                 {
2991                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2992                   insns = arm_gen_constant (AND, mode, cond,
2993                                             remainder | shift_mask,
2994                                             new_src, source, subtargets, 1);
2995                   source = new_src;
2996                 }
2997               else
2998                 {
2999                   rtx targ = subtargets ? NULL_RTX : target;
3000                   insns = arm_gen_constant (AND, mode, cond,
3001                                             remainder | shift_mask,
3002                                             targ, source, subtargets, 0);
3003                 }
3004             }
3005
3006           if (generate)
3007             {
3008               rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3009               rtx shift = GEN_INT (clear_sign_bit_copies);
3010
3011               emit_insn (gen_ashlsi3 (new_src, source, shift));
3012               emit_insn (gen_lshrsi3 (target, new_src, shift));
3013             }
3014
3015           return insns + 2;
3016         }
3017
3018       if (clear_zero_bit_copies >= 16 && clear_zero_bit_copies < 24)
3019         {
3020           HOST_WIDE_INT shift_mask = (1 << clear_zero_bit_copies) - 1;
3021
3022           if ((remainder | shift_mask) != 0xffffffff)
3023             {
3024               if (generate)
3025                 {
3026                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3027
3028                   insns = arm_gen_constant (AND, mode, cond,
3029                                             remainder | shift_mask,
3030                                             new_src, source, subtargets, 1);
3031                   source = new_src;
3032                 }
3033               else
3034                 {
3035                   rtx targ = subtargets ? NULL_RTX : target;
3036
3037                   insns = arm_gen_constant (AND, mode, cond,
3038                                             remainder | shift_mask,
3039                                             targ, source, subtargets, 0);
3040                 }
3041             }
3042
3043           if (generate)
3044             {
3045               rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3046               rtx shift = GEN_INT (clear_zero_bit_copies);
3047
3048               emit_insn (gen_lshrsi3 (new_src, source, shift));
3049               emit_insn (gen_ashlsi3 (target, new_src, shift));
3050             }
3051
3052           return insns + 2;
3053         }
3054
3055       break;
3056
3057     default:
3058       break;
3059     }
3060
3061   for (i = 0; i < 32; i++)
3062     if (remainder & (1 << i))
3063       num_bits_set++;
3064
3065   if ((code == AND)
3066       || (code != IOR && can_invert && num_bits_set > 16))
3067     remainder ^= 0xffffffff;
3068   else if (code == PLUS && num_bits_set > 16)
3069     remainder = (-remainder) & 0xffffffff;
3070
3071   /* For XOR, if more than half the bits are set and there's a sequence
3072      of more than 8 consecutive ones in the pattern then we can XOR by the
3073      inverted constant and then invert the final result; this may save an
3074      instruction and might also lead to the final mvn being merged with
3075      some other operation.  */
3076   else if (code == XOR && num_bits_set > 16
3077            && (count_insns_for_constant (remainder ^ 0xffffffff,
3078                                          find_best_start
3079                                          (remainder ^ 0xffffffff))
3080                < count_insns_for_constant (remainder,
3081                                            find_best_start (remainder))))
3082     {
3083       remainder ^= 0xffffffff;
3084       final_invert = 1;
3085     }
3086   else
3087     {
3088       can_invert = 0;
3089       can_negate = 0;
3090     }
3091
3092   /* Now try and find a way of doing the job in either two or three
3093      instructions.
3094      We start by looking for the largest block of zeros that are aligned on
3095      a 2-bit boundary, we then fill up the temps, wrapping around to the
3096      top of the word when we drop off the bottom.
3097      In the worst case this code should produce no more than four insns.
3098      Thumb-2 constants are shifted, not rotated, so the MSB is always the
3099      best place to start.  */
3100
3101   /* ??? Use thumb2 replicated constants when the high and low halfwords are
3102      the same.  */
3103   {
3104     /* Now start emitting the insns.  */
3105     i = find_best_start (remainder);
3106     do
3107       {
3108         int end;
3109
3110         if (i <= 0)
3111           i += 32;
3112         if (remainder & (3 << (i - 2)))
3113           {
3114             end = i - 8;
3115             if (end < 0)
3116               end += 32;
3117             temp1 = remainder & ((0x0ff << end)
3118                                  | ((i < end) ? (0xff >> (32 - end)) : 0));
3119             remainder &= ~temp1;
3120
3121             if (generate)
3122               {
3123                 rtx new_src, temp1_rtx;
3124
3125                 if (code == SET || code == MINUS)
3126                   {
3127                     new_src = (subtargets ? gen_reg_rtx (mode) : target);
3128                     if (can_invert && code != MINUS)
3129                       temp1 = ~temp1;
3130                   }
3131                 else
3132                   {
3133                     if ((final_invert || remainder) && subtargets)
3134                       new_src = gen_reg_rtx (mode);
3135                     else
3136                       new_src = target;
3137                     if (can_invert)
3138                       temp1 = ~temp1;
3139                     else if (can_negate)
3140                       temp1 = -temp1;
3141                   }
3142
3143                 temp1 = trunc_int_for_mode (temp1, mode);
3144                 temp1_rtx = GEN_INT (temp1);
3145
3146                 if (code == SET)
3147                   ;
3148                 else if (code == MINUS)
3149                   temp1_rtx = gen_rtx_MINUS (mode, temp1_rtx, source);
3150                 else
3151                   temp1_rtx = gen_rtx_fmt_ee (code, mode, source, temp1_rtx);
3152
3153                 emit_constant_insn (cond,
3154                                     gen_rtx_SET (VOIDmode, new_src,
3155                                                  temp1_rtx));
3156                 source = new_src;
3157               }
3158
3159             if (code == SET)
3160               {
3161                 can_invert = 0;
3162                 code = PLUS;
3163               }
3164             else if (code == MINUS)
3165               code = PLUS;
3166
3167             insns++;
3168             i -= 8 - step_size;
3169           }
3170         /* Arm allows rotates by a multiple of two. Thumb-2 allows arbitrary
3171            shifts.  */
3172         i -= step_size;
3173       }
3174     while (remainder);
3175   }
3176
3177   if (final_invert)
3178     {
3179       if (generate)
3180         emit_constant_insn (cond, gen_rtx_SET (VOIDmode, target,
3181                                                gen_rtx_NOT (mode, source)));
3182       insns++;
3183     }
3184
3185   return insns;
3186 }
3187
3188 /* Canonicalize a comparison so that we are more likely to recognize it.
3189    This can be done for a few constant compares, where we can make the
3190    immediate value easier to load.  */
3191
3192 enum rtx_code
3193 arm_canonicalize_comparison (enum rtx_code code, enum machine_mode mode,
3194                              rtx * op1)
3195 {
3196   unsigned HOST_WIDE_INT i = INTVAL (*op1);
3197   unsigned HOST_WIDE_INT maxval;
3198   maxval = (((unsigned HOST_WIDE_INT) 1) << (GET_MODE_BITSIZE(mode) - 1)) - 1;
3199
3200   switch (code)
3201     {
3202     case EQ:
3203     case NE:
3204       return code;
3205
3206     case GT:
3207     case LE:
3208       if (i != maxval
3209           && (const_ok_for_arm (i + 1) || const_ok_for_arm (-(i + 1))))
3210         {
3211           *op1 = GEN_INT (i + 1);
3212           return code == GT ? GE : LT;
3213         }
3214       break;
3215
3216     case GE:
3217     case LT:
3218       if (i != ~maxval
3219           && (const_ok_for_arm (i - 1) || const_ok_for_arm (-(i - 1))))
3220         {
3221           *op1 = GEN_INT (i - 1);
3222           return code == GE ? GT : LE;
3223         }
3224       break;
3225
3226     case GTU:
3227     case LEU:
3228       if (i != ~((unsigned HOST_WIDE_INT) 0)
3229           && (const_ok_for_arm (i + 1) || const_ok_for_arm (-(i + 1))))
3230         {
3231           *op1 = GEN_INT (i + 1);
3232           return code == GTU ? GEU : LTU;
3233         }
3234       break;
3235
3236     case GEU:
3237     case LTU:
3238       if (i != 0
3239           && (const_ok_for_arm (i - 1) || const_ok_for_arm (-(i - 1))))
3240         {
3241           *op1 = GEN_INT (i - 1);
3242           return code == GEU ? GTU : LEU;
3243         }
3244       break;
3245
3246     default:
3247       gcc_unreachable ();
3248     }
3249
3250   return code;
3251 }
3252
3253
3254 /* Define how to find the value returned by a function.  */
3255
3256 static rtx
3257 arm_function_value(const_tree type, const_tree func,
3258                    bool outgoing ATTRIBUTE_UNUSED)
3259 {
3260   enum machine_mode mode;
3261   int unsignedp ATTRIBUTE_UNUSED;
3262   rtx r ATTRIBUTE_UNUSED;
3263
3264   mode = TYPE_MODE (type);
3265
3266   if (TARGET_AAPCS_BASED)
3267     return aapcs_allocate_return_reg (mode, type, func);
3268
3269   /* Promote integer types.  */
3270   if (INTEGRAL_TYPE_P (type))
3271     mode = arm_promote_function_mode (type, mode, &unsignedp, func, 1);
3272
3273   /* Promotes small structs returned in a register to full-word size
3274      for big-endian AAPCS.  */
3275   if (arm_return_in_msb (type))
3276     {
3277       HOST_WIDE_INT size = int_size_in_bytes (type);
3278       if (size % UNITS_PER_WORD != 0)
3279         {
3280           size += UNITS_PER_WORD - size % UNITS_PER_WORD;
3281           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
3282         }
3283     }
3284
3285   return LIBCALL_VALUE (mode);
3286 }
3287
3288 static int
3289 libcall_eq (const void *p1, const void *p2)
3290 {
3291   return rtx_equal_p ((const_rtx) p1, (const_rtx) p2);
3292 }
3293
3294 static hashval_t
3295 libcall_hash (const void *p1)
3296 {
3297   return hash_rtx ((const_rtx) p1, VOIDmode, NULL, NULL, FALSE);
3298 }
3299
3300 static void
3301 add_libcall (htab_t htab, rtx libcall)
3302 {
3303   *htab_find_slot (htab, libcall, INSERT) = libcall;
3304 }
3305
3306 static bool
3307 arm_libcall_uses_aapcs_base (const_rtx libcall)
3308 {
3309   static bool init_done = false;
3310   static htab_t libcall_htab;
3311
3312   if (!init_done)
3313     {
3314       init_done = true;
3315
3316       libcall_htab = htab_create (31, libcall_hash, libcall_eq,
3317                                   NULL);
3318       add_libcall (libcall_htab,
3319                    convert_optab_libfunc (sfloat_optab, SFmode, SImode));
3320       add_libcall (libcall_htab,
3321                    convert_optab_libfunc (sfloat_optab, DFmode, SImode));
3322       add_libcall (libcall_htab,
3323                    convert_optab_libfunc (sfloat_optab, SFmode, DImode));
3324       add_libcall (libcall_htab,
3325                    convert_optab_libfunc (sfloat_optab, DFmode, DImode));
3326       
3327       add_libcall (libcall_htab,
3328                    convert_optab_libfunc (ufloat_optab, SFmode, SImode));
3329       add_libcall (libcall_htab,
3330                    convert_optab_libfunc (ufloat_optab, DFmode, SImode));
3331       add_libcall (libcall_htab,
3332                    convert_optab_libfunc (ufloat_optab, SFmode, DImode));
3333       add_libcall (libcall_htab,
3334                    convert_optab_libfunc (ufloat_optab, DFmode, DImode));
3335
3336       add_libcall (libcall_htab,
3337                    convert_optab_libfunc (sext_optab, SFmode, HFmode));
3338       add_libcall (libcall_htab,
3339                    convert_optab_libfunc (trunc_optab, HFmode, SFmode));
3340       add_libcall (libcall_htab,
3341                    convert_optab_libfunc (sfix_optab, DImode, DFmode));
3342       add_libcall (libcall_htab,
3343                    convert_optab_libfunc (ufix_optab, DImode, DFmode));
3344       add_libcall (libcall_htab,
3345                    convert_optab_libfunc (sfix_optab, DImode, SFmode));
3346       add_libcall (libcall_htab,
3347                    convert_optab_libfunc (ufix_optab, DImode, SFmode));
3348     }
3349
3350   return libcall && htab_find (libcall_htab, libcall) != NULL;
3351 }
3352
3353 rtx
3354 arm_libcall_value (enum machine_mode mode, const_rtx libcall)
3355 {
3356   if (TARGET_AAPCS_BASED && arm_pcs_default != ARM_PCS_AAPCS
3357       && GET_MODE_CLASS (mode) == MODE_FLOAT)
3358     {
3359       /* The following libcalls return their result in integer registers,
3360          even though they return a floating point value.  */
3361       if (arm_libcall_uses_aapcs_base (libcall))
3362         return gen_rtx_REG (mode, ARG_REGISTER(1));
3363
3364     }
3365
3366   return LIBCALL_VALUE (mode);
3367 }
3368
3369 /* Determine the amount of memory needed to store the possible return
3370    registers of an untyped call.  */
3371 int
3372 arm_apply_result_size (void)
3373 {
3374   int size = 16;
3375
3376   if (TARGET_32BIT)
3377     {
3378       if (TARGET_HARD_FLOAT_ABI)
3379         {
3380           if (TARGET_VFP)
3381             size += 32;
3382           if (TARGET_FPA)
3383             size += 12;
3384           if (TARGET_MAVERICK)
3385             size += 8;
3386         }
3387       if (TARGET_IWMMXT_ABI)
3388         size += 8;
3389     }
3390
3391   return size;
3392 }
3393
3394 /* Decide whether TYPE should be returned in memory (true)
3395    or in a register (false).  FNTYPE is the type of the function making
3396    the call.  */
3397 static bool
3398 arm_return_in_memory (const_tree type, const_tree fntype)
3399 {
3400   HOST_WIDE_INT size;
3401
3402   size = int_size_in_bytes (type);  /* Negative if not fixed size.  */
3403
3404   if (TARGET_AAPCS_BASED)
3405     {
3406       /* Simple, non-aggregate types (ie not including vectors and
3407          complex) are always returned in a register (or registers).
3408          We don't care about which register here, so we can short-cut
3409          some of the detail.  */
3410       if (!AGGREGATE_TYPE_P (type)
3411           && TREE_CODE (type) != VECTOR_TYPE
3412           && TREE_CODE (type) != COMPLEX_TYPE)
3413         return false;
3414
3415       /* Any return value that is no larger than one word can be
3416          returned in r0.  */
3417       if (((unsigned HOST_WIDE_INT) size) <= UNITS_PER_WORD)
3418         return false;
3419
3420       /* Check any available co-processors to see if they accept the
3421          type as a register candidate (VFP, for example, can return
3422          some aggregates in consecutive registers).  These aren't
3423          available if the call is variadic.  */
3424       if (aapcs_select_return_coproc (type, fntype) >= 0)
3425         return false;
3426
3427       /* Vector values should be returned using ARM registers, not
3428          memory (unless they're over 16 bytes, which will break since
3429          we only have four call-clobbered registers to play with).  */
3430       if (TREE_CODE (type) == VECTOR_TYPE)
3431         return (size < 0 || size > (4 * UNITS_PER_WORD));