OSDN Git Service

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