OSDN Git Service

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