OSDN Git Service

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