OSDN Git Service

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