OSDN Git Service

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