OSDN Git Service

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