OSDN Git Service

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