OSDN Git Service

df08c467b1611aef785fe39ebd46bf1202623914
[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
461 #define FL_IWMMXT     (1 << 29)       /* XScale v2 or "Intel Wireless MMX technology".  */
462
463 #define FL_FOR_ARCH2    FL_NOTM
464 #define FL_FOR_ARCH3    (FL_FOR_ARCH2 | FL_MODE32)
465 #define FL_FOR_ARCH3M   (FL_FOR_ARCH3 | FL_ARCH3M)
466 #define FL_FOR_ARCH4    (FL_FOR_ARCH3M | FL_ARCH4)
467 #define FL_FOR_ARCH4T   (FL_FOR_ARCH4 | FL_THUMB)
468 #define FL_FOR_ARCH5    (FL_FOR_ARCH4 | FL_ARCH5)
469 #define FL_FOR_ARCH5T   (FL_FOR_ARCH5 | FL_THUMB)
470 #define FL_FOR_ARCH5E   (FL_FOR_ARCH5 | FL_ARCH5E)
471 #define FL_FOR_ARCH5TE  (FL_FOR_ARCH5E | FL_THUMB)
472 #define FL_FOR_ARCH5TEJ FL_FOR_ARCH5TE
473 #define FL_FOR_ARCH6    (FL_FOR_ARCH5TE | FL_ARCH6)
474 #define FL_FOR_ARCH6J   FL_FOR_ARCH6
475 #define FL_FOR_ARCH6K   (FL_FOR_ARCH6 | FL_ARCH6K)
476 #define FL_FOR_ARCH6Z   FL_FOR_ARCH6
477 #define FL_FOR_ARCH6ZK  FL_FOR_ARCH6K
478 #define FL_FOR_ARCH6T2  (FL_FOR_ARCH6 | FL_THUMB2)
479 #define FL_FOR_ARCH7    (FL_FOR_ARCH6T2 &~ FL_NOTM)
480 #define FL_FOR_ARCH7A   (FL_FOR_ARCH7 | FL_NOTM)
481 #define FL_FOR_ARCH7R   (FL_FOR_ARCH7A | FL_DIV)
482 #define FL_FOR_ARCH7M   (FL_FOR_ARCH7 | FL_DIV)
483
484 /* The bits in this mask specify which
485    instructions we are allowed to generate.  */
486 static unsigned long insn_flags = 0;
487
488 /* The bits in this mask specify which instruction scheduling options should
489    be used.  */
490 static unsigned long tune_flags = 0;
491
492 /* The following are used in the arm.md file as equivalents to bits
493    in the above two flag variables.  */
494
495 /* Nonzero if this chip supports the ARM Architecture 3M extensions.  */
496 int arm_arch3m = 0;
497
498 /* Nonzero if this chip supports the ARM Architecture 4 extensions.  */
499 int arm_arch4 = 0;
500
501 /* Nonzero if this chip supports the ARM Architecture 4t extensions.  */
502 int arm_arch4t = 0;
503
504 /* Nonzero if this chip supports the ARM Architecture 5 extensions.  */
505 int arm_arch5 = 0;
506
507 /* Nonzero if this chip supports the ARM Architecture 5E extensions.  */
508 int arm_arch5e = 0;
509
510 /* Nonzero if this chip supports the ARM Architecture 6 extensions.  */
511 int arm_arch6 = 0;
512
513 /* Nonzero if this chip supports the ARM 6K extensions.  */
514 int arm_arch6k = 0;
515
516 /* Nonzero if instructions not present in the 'M' profile can be used.  */
517 int arm_arch_notm = 0;
518
519 /* Nonzero if this chip can benefit from load scheduling.  */
520 int arm_ld_sched = 0;
521
522 /* Nonzero if this chip is a StrongARM.  */
523 int arm_tune_strongarm = 0;
524
525 /* Nonzero if this chip is a Cirrus variant.  */
526 int arm_arch_cirrus = 0;
527
528 /* Nonzero if this chip supports Intel Wireless MMX technology.  */
529 int arm_arch_iwmmxt = 0;
530
531 /* Nonzero if this chip is an XScale.  */
532 int arm_arch_xscale = 0;
533
534 /* Nonzero if tuning for XScale  */
535 int arm_tune_xscale = 0;
536
537 /* Nonzero if we want to tune for stores that access the write-buffer.
538    This typically means an ARM6 or ARM7 with MMU or MPU.  */
539 int arm_tune_wbuf = 0;
540
541 /* Nonzero if generating Thumb instructions.  */
542 int thumb_code = 0;
543
544 /* Nonzero if we should define __THUMB_INTERWORK__ in the
545    preprocessor.
546    XXX This is a bit of a hack, it's intended to help work around
547    problems in GLD which doesn't understand that armv5t code is
548    interworking clean.  */
549 int arm_cpp_interwork = 0;
550
551 /* Nonzero if chip supports Thumb 2.  */
552 int arm_arch_thumb2;
553
554 /* Nonzero if chip supports integer division instruction.  */
555 int arm_arch_hwdiv;
556
557 /* In case of a PRE_INC, POST_INC, PRE_DEC, POST_DEC memory reference, we
558    must report the mode of the memory reference from PRINT_OPERAND to
559    PRINT_OPERAND_ADDRESS.  */
560 enum machine_mode output_memory_reference_mode;
561
562 /* The register number to be used for the PIC offset register.  */
563 unsigned arm_pic_register = INVALID_REGNUM;
564
565 /* Set to 1 when a return insn is output, this means that the epilogue
566    is not needed.  */
567 int return_used_this_function;
568
569 /* Set to 1 after arm_reorg has started.  Reset to start at the start of
570    the next function.  */
571 static int after_arm_reorg = 0;
572
573 /* The maximum number of insns to be used when loading a constant.  */
574 static int arm_constant_limit = 3;
575
576 /* For an explanation of these variables, see final_prescan_insn below.  */
577 int arm_ccfsm_state;
578 /* arm_current_cc is also used for Thumb-2 cond_exec blocks.  */
579 enum arm_cond_code arm_current_cc;
580 rtx arm_target_insn;
581 int arm_target_label;
582 /* The number of conditionally executed insns, including the current insn.  */
583 int arm_condexec_count = 0;
584 /* A bitmask specifying the patterns for the IT block.
585    Zero means do not output an IT block before this insn. */
586 int arm_condexec_mask = 0;
587 /* The number of bits used in arm_condexec_mask.  */
588 int arm_condexec_masklen = 0;
589
590 /* The condition codes of the ARM, and the inverse function.  */
591 static const char * const arm_condition_codes[] =
592 {
593   "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
594   "hi", "ls", "ge", "lt", "gt", "le", "al", "nv"
595 };
596
597 #define ARM_LSL_NAME (TARGET_UNIFIED_ASM ? "lsl" : "asl")
598 #define streq(string1, string2) (strcmp (string1, string2) == 0)
599
600 #define THUMB2_WORK_REGS (0xff & ~(  (1 << THUMB_HARD_FRAME_POINTER_REGNUM) \
601                                    | (1 << SP_REGNUM) | (1 << PC_REGNUM) \
602                                    | (1 << PIC_OFFSET_TABLE_REGNUM)))
603 \f
604 /* Initialization code.  */
605
606 struct processors
607 {
608   const char *const name;
609   enum processor_type core;
610   const char *arch;
611   const unsigned long flags;
612   bool (* rtx_costs) (rtx, int, int, int *);
613 };
614
615 /* Not all of these give usefully different compilation alternatives,
616    but there is no simple way of generalizing them.  */
617 static const struct processors all_cores[] =
618 {
619   /* ARM Cores */
620 #define ARM_CORE(NAME, IDENT, ARCH, FLAGS, COSTS) \
621   {NAME, arm_none, #ARCH, FLAGS | FL_FOR_ARCH##ARCH, arm_##COSTS##_rtx_costs},
622 #include "arm-cores.def"
623 #undef ARM_CORE
624   {NULL, arm_none, NULL, 0, NULL}
625 };
626
627 static const struct processors all_architectures[] =
628 {
629   /* ARM Architectures */
630   /* We don't specify rtx_costs here as it will be figured out
631      from the core.  */
632
633   {"armv2",   arm2,       "2",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH2, NULL},
634   {"armv2a",  arm2,       "2",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH2, NULL},
635   {"armv3",   arm6,       "3",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH3, NULL},
636   {"armv3m",  arm7m,      "3M",  FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH3M, NULL},
637   {"armv4",   arm7tdmi,   "4",   FL_CO_PROC | FL_MODE26 | FL_FOR_ARCH4, NULL},
638   /* Strictly, FL_MODE26 is a permitted option for v4t, but there are no
639      implementations that support it, so we will leave it out for now.  */
640   {"armv4t",  arm7tdmi,   "4T",  FL_CO_PROC |             FL_FOR_ARCH4T, NULL},
641   {"armv5",   arm10tdmi,  "5",   FL_CO_PROC |             FL_FOR_ARCH5, NULL},
642   {"armv5t",  arm10tdmi,  "5T",  FL_CO_PROC |             FL_FOR_ARCH5T, NULL},
643   {"armv5e",  arm1026ejs, "5E",  FL_CO_PROC |             FL_FOR_ARCH5E, NULL},
644   {"armv5te", arm1026ejs, "5TE", FL_CO_PROC |             FL_FOR_ARCH5TE, NULL},
645   {"armv6",   arm1136js,  "6",   FL_CO_PROC |             FL_FOR_ARCH6, NULL},
646   {"armv6j",  arm1136js,  "6J",  FL_CO_PROC |             FL_FOR_ARCH6J, NULL},
647   {"armv6k",  mpcore,     "6K",  FL_CO_PROC |             FL_FOR_ARCH6K, NULL},
648   {"armv6z",  arm1176jzs, "6Z",  FL_CO_PROC |             FL_FOR_ARCH6Z, NULL},
649   {"armv6zk", arm1176jzs, "6ZK", FL_CO_PROC |             FL_FOR_ARCH6ZK, NULL},
650   {"armv6t2", arm1156t2s, "6T2", FL_CO_PROC |             FL_FOR_ARCH6T2, NULL},
651   {"armv7",   cortexa8,   "7",   FL_CO_PROC |             FL_FOR_ARCH7, NULL},
652   {"armv7-a", cortexa8,   "7A",  FL_CO_PROC |             FL_FOR_ARCH7A, NULL},
653   {"armv7-r", cortexr4,   "7R",  FL_CO_PROC |             FL_FOR_ARCH7R, NULL},
654   {"armv7-m", cortexm3,   "7M",  FL_CO_PROC |             FL_FOR_ARCH7M, NULL},
655   {"ep9312",  ep9312,     "4T",  FL_LDSCHED | FL_CIRRUS | FL_FOR_ARCH4, NULL},
656   {"iwmmxt",  iwmmxt,     "5TE", FL_LDSCHED | FL_STRONG | FL_FOR_ARCH5TE | FL_XSCALE | FL_IWMMXT , NULL},
657   {NULL, arm_none, NULL, 0 , NULL}
658 };
659
660 struct arm_cpu_select
661 {
662   const char *              string;
663   const char *              name;
664   const struct processors * processors;
665 };
666
667 /* This is a magic structure.  The 'string' field is magically filled in
668    with a pointer to the value specified by the user on the command line
669    assuming that the user has specified such a value.  */
670
671 static struct arm_cpu_select arm_select[] =
672 {
673   /* string       name            processors  */
674   { NULL,       "-mcpu=",       all_cores  },
675   { NULL,       "-march=",      all_architectures },
676   { NULL,       "-mtune=",      all_cores }
677 };
678
679 /* Defines representing the indexes into the above table.  */
680 #define ARM_OPT_SET_CPU 0
681 #define ARM_OPT_SET_ARCH 1
682 #define ARM_OPT_SET_TUNE 2
683
684 /* The name of the preprocessor macro to define for this architecture.  */
685
686 char arm_arch_name[] = "__ARM_ARCH_0UNK__";
687
688 struct fpu_desc
689 {
690   const char * name;
691   enum fputype fpu;
692 };
693
694
695 /* Available values for -mfpu=.  */
696
697 static const struct fpu_desc all_fpus[] =
698 {
699   {"fpa",       FPUTYPE_FPA},
700   {"fpe2",      FPUTYPE_FPA_EMU2},
701   {"fpe3",      FPUTYPE_FPA_EMU2},
702   {"maverick",  FPUTYPE_MAVERICK},
703   {"vfp",       FPUTYPE_VFP}
704 };
705
706
707 /* Floating point models used by the different hardware.
708    See fputype in arm.h.  */
709
710 static const enum fputype fp_model_for_fpu[] =
711 {
712   /* No FP hardware.  */
713   ARM_FP_MODEL_UNKNOWN,         /* FPUTYPE_NONE  */
714   ARM_FP_MODEL_FPA,             /* FPUTYPE_FPA  */
715   ARM_FP_MODEL_FPA,             /* FPUTYPE_FPA_EMU2  */
716   ARM_FP_MODEL_FPA,             /* FPUTYPE_FPA_EMU3  */
717   ARM_FP_MODEL_MAVERICK,        /* FPUTYPE_MAVERICK  */
718   ARM_FP_MODEL_VFP              /* FPUTYPE_VFP  */
719 };
720
721
722 struct float_abi
723 {
724   const char * name;
725   enum float_abi_type abi_type;
726 };
727
728
729 /* Available values for -mfloat-abi=.  */
730
731 static const struct float_abi all_float_abis[] =
732 {
733   {"soft",      ARM_FLOAT_ABI_SOFT},
734   {"softfp",    ARM_FLOAT_ABI_SOFTFP},
735   {"hard",      ARM_FLOAT_ABI_HARD}
736 };
737
738
739 struct abi_name
740 {
741   const char *name;
742   enum arm_abi_type abi_type;
743 };
744
745
746 /* Available values for -mabi=.  */
747
748 static const struct abi_name arm_all_abis[] =
749 {
750   {"apcs-gnu",    ARM_ABI_APCS},
751   {"atpcs",   ARM_ABI_ATPCS},
752   {"aapcs",   ARM_ABI_AAPCS},
753   {"iwmmxt",  ARM_ABI_IWMMXT},
754   {"aapcs-linux",   ARM_ABI_AAPCS_LINUX}
755 };
756
757 /* Supported TLS relocations.  */
758
759 enum tls_reloc {
760   TLS_GD32,
761   TLS_LDM32,
762   TLS_LDO32,
763   TLS_IE32,
764   TLS_LE32
765 };
766
767 /* Emit an insn that's a simple single-set.  Both the operands must be known
768    to be valid.  */
769 inline static rtx
770 emit_set_insn (rtx x, rtx y)
771 {
772   return emit_insn (gen_rtx_SET (VOIDmode, x, y));
773 }
774
775 /* Return the number of bits set in VALUE.  */
776 static unsigned
777 bit_count (unsigned long value)
778 {
779   unsigned long count = 0;
780
781   while (value)
782     {
783       count++;
784       value &= value - 1;  /* Clear the least-significant set bit.  */
785     }
786
787   return count;
788 }
789
790 /* Set up library functions unique to ARM.  */
791
792 static void
793 arm_init_libfuncs (void)
794 {
795   /* There are no special library functions unless we are using the
796      ARM BPABI.  */
797   if (!TARGET_BPABI)
798     return;
799
800   /* The functions below are described in Section 4 of the "Run-Time
801      ABI for the ARM architecture", Version 1.0.  */
802
803   /* Double-precision floating-point arithmetic.  Table 2.  */
804   set_optab_libfunc (add_optab, DFmode, "__aeabi_dadd");
805   set_optab_libfunc (sdiv_optab, DFmode, "__aeabi_ddiv");
806   set_optab_libfunc (smul_optab, DFmode, "__aeabi_dmul");
807   set_optab_libfunc (neg_optab, DFmode, "__aeabi_dneg");
808   set_optab_libfunc (sub_optab, DFmode, "__aeabi_dsub");
809
810   /* Double-precision comparisons.  Table 3.  */
811   set_optab_libfunc (eq_optab, DFmode, "__aeabi_dcmpeq");
812   set_optab_libfunc (ne_optab, DFmode, NULL);
813   set_optab_libfunc (lt_optab, DFmode, "__aeabi_dcmplt");
814   set_optab_libfunc (le_optab, DFmode, "__aeabi_dcmple");
815   set_optab_libfunc (ge_optab, DFmode, "__aeabi_dcmpge");
816   set_optab_libfunc (gt_optab, DFmode, "__aeabi_dcmpgt");
817   set_optab_libfunc (unord_optab, DFmode, "__aeabi_dcmpun");
818
819   /* Single-precision floating-point arithmetic.  Table 4.  */
820   set_optab_libfunc (add_optab, SFmode, "__aeabi_fadd");
821   set_optab_libfunc (sdiv_optab, SFmode, "__aeabi_fdiv");
822   set_optab_libfunc (smul_optab, SFmode, "__aeabi_fmul");
823   set_optab_libfunc (neg_optab, SFmode, "__aeabi_fneg");
824   set_optab_libfunc (sub_optab, SFmode, "__aeabi_fsub");
825
826   /* Single-precision comparisons.  Table 5.  */
827   set_optab_libfunc (eq_optab, SFmode, "__aeabi_fcmpeq");
828   set_optab_libfunc (ne_optab, SFmode, NULL);
829   set_optab_libfunc (lt_optab, SFmode, "__aeabi_fcmplt");
830   set_optab_libfunc (le_optab, SFmode, "__aeabi_fcmple");
831   set_optab_libfunc (ge_optab, SFmode, "__aeabi_fcmpge");
832   set_optab_libfunc (gt_optab, SFmode, "__aeabi_fcmpgt");
833   set_optab_libfunc (unord_optab, SFmode, "__aeabi_fcmpun");
834
835   /* Floating-point to integer conversions.  Table 6.  */
836   set_conv_libfunc (sfix_optab, SImode, DFmode, "__aeabi_d2iz");
837   set_conv_libfunc (ufix_optab, SImode, DFmode, "__aeabi_d2uiz");
838   set_conv_libfunc (sfix_optab, DImode, DFmode, "__aeabi_d2lz");
839   set_conv_libfunc (ufix_optab, DImode, DFmode, "__aeabi_d2ulz");
840   set_conv_libfunc (sfix_optab, SImode, SFmode, "__aeabi_f2iz");
841   set_conv_libfunc (ufix_optab, SImode, SFmode, "__aeabi_f2uiz");
842   set_conv_libfunc (sfix_optab, DImode, SFmode, "__aeabi_f2lz");
843   set_conv_libfunc (ufix_optab, DImode, SFmode, "__aeabi_f2ulz");
844
845   /* Conversions between floating types.  Table 7.  */
846   set_conv_libfunc (trunc_optab, SFmode, DFmode, "__aeabi_d2f");
847   set_conv_libfunc (sext_optab, DFmode, SFmode, "__aeabi_f2d");
848
849   /* Integer to floating-point conversions.  Table 8.  */
850   set_conv_libfunc (sfloat_optab, DFmode, SImode, "__aeabi_i2d");
851   set_conv_libfunc (ufloat_optab, DFmode, SImode, "__aeabi_ui2d");
852   set_conv_libfunc (sfloat_optab, DFmode, DImode, "__aeabi_l2d");
853   set_conv_libfunc (ufloat_optab, DFmode, DImode, "__aeabi_ul2d");
854   set_conv_libfunc (sfloat_optab, SFmode, SImode, "__aeabi_i2f");
855   set_conv_libfunc (ufloat_optab, SFmode, SImode, "__aeabi_ui2f");
856   set_conv_libfunc (sfloat_optab, SFmode, DImode, "__aeabi_l2f");
857   set_conv_libfunc (ufloat_optab, SFmode, DImode, "__aeabi_ul2f");
858
859   /* Long long.  Table 9.  */
860   set_optab_libfunc (smul_optab, DImode, "__aeabi_lmul");
861   set_optab_libfunc (sdivmod_optab, DImode, "__aeabi_ldivmod");
862   set_optab_libfunc (udivmod_optab, DImode, "__aeabi_uldivmod");
863   set_optab_libfunc (ashl_optab, DImode, "__aeabi_llsl");
864   set_optab_libfunc (lshr_optab, DImode, "__aeabi_llsr");
865   set_optab_libfunc (ashr_optab, DImode, "__aeabi_lasr");
866   set_optab_libfunc (cmp_optab, DImode, "__aeabi_lcmp");
867   set_optab_libfunc (ucmp_optab, DImode, "__aeabi_ulcmp");
868
869   /* Integer (32/32->32) division.  \S 4.3.1.  */
870   set_optab_libfunc (sdivmod_optab, SImode, "__aeabi_idivmod");
871   set_optab_libfunc (udivmod_optab, SImode, "__aeabi_uidivmod");
872
873   /* The divmod functions are designed so that they can be used for
874      plain division, even though they return both the quotient and the
875      remainder.  The quotient is returned in the usual location (i.e.,
876      r0 for SImode, {r0, r1} for DImode), just as would be expected
877      for an ordinary division routine.  Because the AAPCS calling
878      conventions specify that all of { r0, r1, r2, r3 } are
879      callee-saved registers, there is no need to tell the compiler
880      explicitly that those registers are clobbered by these
881      routines.  */
882   set_optab_libfunc (sdiv_optab, DImode, "__aeabi_ldivmod");
883   set_optab_libfunc (udiv_optab, DImode, "__aeabi_uldivmod");
884
885   /* For SImode division the ABI provides div-without-mod routines,
886      which are faster.  */
887   set_optab_libfunc (sdiv_optab, SImode, "__aeabi_idiv");
888   set_optab_libfunc (udiv_optab, SImode, "__aeabi_uidiv");
889
890   /* We don't have mod libcalls.  Fortunately gcc knows how to use the
891      divmod libcalls instead.  */
892   set_optab_libfunc (smod_optab, DImode, NULL);
893   set_optab_libfunc (umod_optab, DImode, NULL);
894   set_optab_libfunc (smod_optab, SImode, NULL);
895   set_optab_libfunc (umod_optab, SImode, NULL);
896 }
897
898 /* Implement TARGET_HANDLE_OPTION.  */
899
900 static bool
901 arm_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
902 {
903   switch (code)
904     {
905     case OPT_march_:
906       arm_select[1].string = arg;
907       return true;
908
909     case OPT_mcpu_:
910       arm_select[0].string = arg;
911       return true;
912
913     case OPT_mhard_float:
914       target_float_abi_name = "hard";
915       return true;
916
917     case OPT_msoft_float:
918       target_float_abi_name = "soft";
919       return true;
920
921     case OPT_mtune_:
922       arm_select[2].string = arg;
923       return true;
924
925     default:
926       return true;
927     }
928 }
929
930 /* Fix up any incompatible options that the user has specified.
931    This has now turned into a maze.  */
932 void
933 arm_override_options (void)
934 {
935   unsigned i;
936   enum processor_type target_arch_cpu = arm_none;
937
938   /* Set up the flags based on the cpu/architecture selected by the user.  */
939   for (i = ARRAY_SIZE (arm_select); i--;)
940     {
941       struct arm_cpu_select * ptr = arm_select + i;
942
943       if (ptr->string != NULL && ptr->string[0] != '\0')
944         {
945           const struct processors * sel;
946
947           for (sel = ptr->processors; sel->name != NULL; sel++)
948             if (streq (ptr->string, sel->name))
949               {
950                 /* Set the architecture define.  */
951                 if (i != ARM_OPT_SET_TUNE)
952                   sprintf (arm_arch_name, "__ARM_ARCH_%s__", sel->arch);
953
954                 /* Determine the processor core for which we should
955                    tune code-generation.  */
956                 if (/* -mcpu= is a sensible default.  */
957                     i == ARM_OPT_SET_CPU
958                     /* -mtune= overrides -mcpu= and -march=.  */
959                     || i == ARM_OPT_SET_TUNE)
960                   arm_tune = (enum processor_type) (sel - ptr->processors);
961
962                 /* Remember the CPU associated with this architecture.
963                    If no other option is used to set the CPU type,
964                    we'll use this to guess the most suitable tuning
965                    options.  */
966                 if (i == ARM_OPT_SET_ARCH)
967                   target_arch_cpu = sel->core;
968
969                 if (i != ARM_OPT_SET_TUNE)
970                   {
971                     /* If we have been given an architecture and a processor
972                        make sure that they are compatible.  We only generate
973                        a warning though, and we prefer the CPU over the
974                        architecture.  */
975                     if (insn_flags != 0 && (insn_flags ^ sel->flags))
976                       warning (0, "switch -mcpu=%s conflicts with -march= switch",
977                                ptr->string);
978
979                     insn_flags = sel->flags;
980                   }
981
982                 break;
983               }
984
985           if (sel->name == NULL)
986             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
987         }
988     }
989
990   /* Guess the tuning options from the architecture if necessary.  */
991   if (arm_tune == arm_none)
992     arm_tune = target_arch_cpu;
993
994   /* If the user did not specify a processor, choose one for them.  */
995   if (insn_flags == 0)
996     {
997       const struct processors * sel;
998       unsigned int        sought;
999       enum processor_type cpu;
1000
1001       cpu = TARGET_CPU_DEFAULT;
1002       if (cpu == arm_none)
1003         {
1004 #ifdef SUBTARGET_CPU_DEFAULT
1005           /* Use the subtarget default CPU if none was specified by
1006              configure.  */
1007           cpu = SUBTARGET_CPU_DEFAULT;
1008 #endif
1009           /* Default to ARM6.  */
1010           if (cpu == arm_none)
1011             cpu = arm6;
1012         }
1013       sel = &all_cores[cpu];
1014
1015       insn_flags = sel->flags;
1016
1017       /* Now check to see if the user has specified some command line
1018          switch that require certain abilities from the cpu.  */
1019       sought = 0;
1020
1021       if (TARGET_INTERWORK || TARGET_THUMB)
1022         {
1023           sought |= (FL_THUMB | FL_MODE32);
1024
1025           /* There are no ARM processors that support both APCS-26 and
1026              interworking.  Therefore we force FL_MODE26 to be removed
1027              from insn_flags here (if it was set), so that the search
1028              below will always be able to find a compatible processor.  */
1029           insn_flags &= ~FL_MODE26;
1030         }
1031
1032       if (sought != 0 && ((sought & insn_flags) != sought))
1033         {
1034           /* Try to locate a CPU type that supports all of the abilities
1035              of the default CPU, plus the extra abilities requested by
1036              the user.  */
1037           for (sel = all_cores; sel->name != NULL; sel++)
1038             if ((sel->flags & sought) == (sought | insn_flags))
1039               break;
1040
1041           if (sel->name == NULL)
1042             {
1043               unsigned current_bit_count = 0;
1044               const struct processors * best_fit = NULL;
1045
1046               /* Ideally we would like to issue an error message here
1047                  saying that it was not possible to find a CPU compatible
1048                  with the default CPU, but which also supports the command
1049                  line options specified by the programmer, and so they
1050                  ought to use the -mcpu=<name> command line option to
1051                  override the default CPU type.
1052
1053                  If we cannot find a cpu that has both the
1054                  characteristics of the default cpu and the given
1055                  command line options we scan the array again looking
1056                  for a best match.  */
1057               for (sel = all_cores; sel->name != NULL; sel++)
1058                 if ((sel->flags & sought) == sought)
1059                   {
1060                     unsigned count;
1061
1062                     count = bit_count (sel->flags & insn_flags);
1063
1064                     if (count >= current_bit_count)
1065                       {
1066                         best_fit = sel;
1067                         current_bit_count = count;
1068                       }
1069                   }
1070
1071               gcc_assert (best_fit);
1072               sel = best_fit;
1073             }
1074
1075           insn_flags = sel->flags;
1076         }
1077       sprintf (arm_arch_name, "__ARM_ARCH_%s__", sel->arch);
1078       arm_default_cpu = (enum processor_type) (sel - all_cores);
1079       if (arm_tune == arm_none)
1080         arm_tune = arm_default_cpu;
1081     }
1082
1083   /* The processor for which we should tune should now have been
1084      chosen.  */
1085   gcc_assert (arm_tune != arm_none);
1086
1087   tune_flags = all_cores[(int)arm_tune].flags;
1088   if (optimize_size)
1089     targetm.rtx_costs = arm_size_rtx_costs;
1090   else
1091     targetm.rtx_costs = all_cores[(int)arm_tune].rtx_costs;
1092
1093   /* Make sure that the processor choice does not conflict with any of the
1094      other command line choices.  */
1095   if (TARGET_ARM && !(insn_flags & FL_NOTM))
1096     error ("target CPU does not support ARM mode");
1097
1098   if (TARGET_INTERWORK && !(insn_flags & FL_THUMB))
1099     {
1100       warning (0, "target CPU does not support interworking" );
1101       target_flags &= ~MASK_INTERWORK;
1102     }
1103
1104   if (TARGET_THUMB && !(insn_flags & FL_THUMB))
1105     {
1106       warning (0, "target CPU does not support THUMB instructions");
1107       target_flags &= ~MASK_THUMB;
1108     }
1109
1110   if (TARGET_APCS_FRAME && TARGET_THUMB)
1111     {
1112       /* warning (0, "ignoring -mapcs-frame because -mthumb was used"); */
1113       target_flags &= ~MASK_APCS_FRAME;
1114     }
1115
1116   /* Callee super interworking implies thumb interworking.  Adding
1117      this to the flags here simplifies the logic elsewhere.  */
1118   if (TARGET_THUMB && TARGET_CALLEE_INTERWORKING)
1119       target_flags |= MASK_INTERWORK;
1120
1121   /* TARGET_BACKTRACE calls leaf_function_p, which causes a crash if done
1122      from here where no function is being compiled currently.  */
1123   if ((TARGET_TPCS_FRAME || TARGET_TPCS_LEAF_FRAME) && TARGET_ARM)
1124     warning (0, "enabling backtrace support is only meaningful when compiling for the Thumb");
1125
1126   if (TARGET_ARM && TARGET_CALLEE_INTERWORKING)
1127     warning (0, "enabling callee interworking support is only meaningful when compiling for the Thumb");
1128
1129   if (TARGET_ARM && TARGET_CALLER_INTERWORKING)
1130     warning (0, "enabling caller interworking support is only meaningful when compiling for the Thumb");
1131
1132   if (TARGET_APCS_STACK && !TARGET_APCS_FRAME)
1133     {
1134       warning (0, "-mapcs-stack-check incompatible with -mno-apcs-frame");
1135       target_flags |= MASK_APCS_FRAME;
1136     }
1137
1138   if (TARGET_POKE_FUNCTION_NAME)
1139     target_flags |= MASK_APCS_FRAME;
1140
1141   if (TARGET_APCS_REENT && flag_pic)
1142     error ("-fpic and -mapcs-reent are incompatible");
1143
1144   if (TARGET_APCS_REENT)
1145     warning (0, "APCS reentrant code not supported.  Ignored");
1146
1147   /* If this target is normally configured to use APCS frames, warn if they
1148      are turned off and debugging is turned on.  */
1149   if (TARGET_ARM
1150       && write_symbols != NO_DEBUG
1151       && !TARGET_APCS_FRAME
1152       && (TARGET_DEFAULT & MASK_APCS_FRAME))
1153     warning (0, "-g with -mno-apcs-frame may not give sensible debugging");
1154
1155   if (TARGET_APCS_FLOAT)
1156     warning (0, "passing floating point arguments in fp regs not yet supported");
1157
1158   /* Initialize boolean versions of the flags, for use in the arm.md file.  */
1159   arm_arch3m = (insn_flags & FL_ARCH3M) != 0;
1160   arm_arch4 = (insn_flags & FL_ARCH4) != 0;
1161   arm_arch4t = arm_arch4 & ((insn_flags & FL_THUMB) != 0);
1162   arm_arch5 = (insn_flags & FL_ARCH5) != 0;
1163   arm_arch5e = (insn_flags & FL_ARCH5E) != 0;
1164   arm_arch6 = (insn_flags & FL_ARCH6) != 0;
1165   arm_arch6k = (insn_flags & FL_ARCH6K) != 0;
1166   arm_arch_notm = (insn_flags & FL_NOTM) != 0;
1167   arm_arch_thumb2 = (insn_flags & FL_THUMB2) != 0;
1168   arm_arch_xscale = (insn_flags & FL_XSCALE) != 0;
1169   arm_arch_cirrus = (insn_flags & FL_CIRRUS) != 0;
1170
1171   arm_ld_sched = (tune_flags & FL_LDSCHED) != 0;
1172   arm_tune_strongarm = (tune_flags & FL_STRONG) != 0;
1173   thumb_code = (TARGET_ARM == 0);
1174   arm_tune_wbuf = (tune_flags & FL_WBUF) != 0;
1175   arm_tune_xscale = (tune_flags & FL_XSCALE) != 0;
1176   arm_arch_iwmmxt = (insn_flags & FL_IWMMXT) != 0;
1177   arm_arch_hwdiv = (insn_flags & FL_DIV) != 0;
1178
1179   /* V5 code we generate is completely interworking capable, so we turn off
1180      TARGET_INTERWORK here to avoid many tests later on.  */
1181
1182   /* XXX However, we must pass the right pre-processor defines to CPP
1183      or GLD can get confused.  This is a hack.  */
1184   if (TARGET_INTERWORK)
1185     arm_cpp_interwork = 1;
1186
1187   if (arm_arch5)
1188     target_flags &= ~MASK_INTERWORK;
1189
1190   if (target_abi_name)
1191     {
1192       for (i = 0; i < ARRAY_SIZE (arm_all_abis); i++)
1193         {
1194           if (streq (arm_all_abis[i].name, target_abi_name))
1195             {
1196               arm_abi = arm_all_abis[i].abi_type;
1197               break;
1198             }
1199         }
1200       if (i == ARRAY_SIZE (arm_all_abis))
1201         error ("invalid ABI option: -mabi=%s", target_abi_name);
1202     }
1203   else
1204     arm_abi = ARM_DEFAULT_ABI;
1205
1206   if (TARGET_IWMMXT && !ARM_DOUBLEWORD_ALIGN)
1207     error ("iwmmxt requires an AAPCS compatible ABI for proper operation");
1208
1209   if (TARGET_IWMMXT_ABI && !TARGET_IWMMXT)
1210     error ("iwmmxt abi requires an iwmmxt capable cpu");
1211
1212   arm_fp_model = ARM_FP_MODEL_UNKNOWN;
1213   if (target_fpu_name == NULL && target_fpe_name != NULL)
1214     {
1215       if (streq (target_fpe_name, "2"))
1216         target_fpu_name = "fpe2";
1217       else if (streq (target_fpe_name, "3"))
1218         target_fpu_name = "fpe3";
1219       else
1220         error ("invalid floating point emulation option: -mfpe=%s",
1221                target_fpe_name);
1222     }
1223   if (target_fpu_name != NULL)
1224     {
1225       /* The user specified a FPU.  */
1226       for (i = 0; i < ARRAY_SIZE (all_fpus); i++)
1227         {
1228           if (streq (all_fpus[i].name, target_fpu_name))
1229             {
1230               arm_fpu_arch = all_fpus[i].fpu;
1231               arm_fpu_tune = arm_fpu_arch;
1232               arm_fp_model = fp_model_for_fpu[arm_fpu_arch];
1233               break;
1234             }
1235         }
1236       if (arm_fp_model == ARM_FP_MODEL_UNKNOWN)
1237         error ("invalid floating point option: -mfpu=%s", target_fpu_name);
1238     }
1239   else
1240     {
1241 #ifdef FPUTYPE_DEFAULT
1242       /* Use the default if it is specified for this platform.  */
1243       arm_fpu_arch = FPUTYPE_DEFAULT;
1244       arm_fpu_tune = FPUTYPE_DEFAULT;
1245 #else
1246       /* Pick one based on CPU type.  */
1247       /* ??? Some targets assume FPA is the default.
1248       if ((insn_flags & FL_VFP) != 0)
1249         arm_fpu_arch = FPUTYPE_VFP;
1250       else
1251       */
1252       if (arm_arch_cirrus)
1253         arm_fpu_arch = FPUTYPE_MAVERICK;
1254       else
1255         arm_fpu_arch = FPUTYPE_FPA_EMU2;
1256 #endif
1257       if (tune_flags & FL_CO_PROC && arm_fpu_arch == FPUTYPE_FPA_EMU2)
1258         arm_fpu_tune = FPUTYPE_FPA;
1259       else
1260         arm_fpu_tune = arm_fpu_arch;
1261       arm_fp_model = fp_model_for_fpu[arm_fpu_arch];
1262       gcc_assert (arm_fp_model != ARM_FP_MODEL_UNKNOWN);
1263     }
1264
1265   if (target_float_abi_name != NULL)
1266     {
1267       /* The user specified a FP ABI.  */
1268       for (i = 0; i < ARRAY_SIZE (all_float_abis); i++)
1269         {
1270           if (streq (all_float_abis[i].name, target_float_abi_name))
1271             {
1272               arm_float_abi = all_float_abis[i].abi_type;
1273               break;
1274             }
1275         }
1276       if (i == ARRAY_SIZE (all_float_abis))
1277         error ("invalid floating point abi: -mfloat-abi=%s",
1278                target_float_abi_name);
1279     }
1280   else
1281     arm_float_abi = TARGET_DEFAULT_FLOAT_ABI;
1282
1283   if (arm_float_abi == ARM_FLOAT_ABI_HARD && TARGET_VFP)
1284     sorry ("-mfloat-abi=hard and VFP");
1285
1286   /* FPA and iWMMXt are incompatible because the insn encodings overlap.
1287      VFP and iWMMXt can theoretically coexist, but it's unlikely such silicon
1288      will ever exist.  GCC makes no attempt to support this combination.  */
1289   if (TARGET_IWMMXT && !TARGET_SOFT_FLOAT)
1290     sorry ("iWMMXt and hardware floating point");
1291
1292   /* ??? iWMMXt insn patterns need auditing for Thumb-2.  */
1293   if (TARGET_THUMB2 && TARGET_IWMMXT)
1294     sorry ("Thumb-2 iWMMXt");
1295
1296   /* If soft-float is specified then don't use FPU.  */
1297   if (TARGET_SOFT_FLOAT)
1298     arm_fpu_arch = FPUTYPE_NONE;
1299
1300   /* For arm2/3 there is no need to do any scheduling if there is only
1301      a floating point emulator, or we are doing software floating-point.  */
1302   if ((TARGET_SOFT_FLOAT
1303        || arm_fpu_tune == FPUTYPE_FPA_EMU2
1304        || arm_fpu_tune == FPUTYPE_FPA_EMU3)
1305       && (tune_flags & FL_MODE32) == 0)
1306     flag_schedule_insns = flag_schedule_insns_after_reload = 0;
1307
1308   if (target_thread_switch)
1309     {
1310       if (strcmp (target_thread_switch, "soft") == 0)
1311         target_thread_pointer = TP_SOFT;
1312       else if (strcmp (target_thread_switch, "auto") == 0)
1313         target_thread_pointer = TP_AUTO;
1314       else if (strcmp (target_thread_switch, "cp15") == 0)
1315         target_thread_pointer = TP_CP15;
1316       else
1317         error ("invalid thread pointer option: -mtp=%s", target_thread_switch);
1318     }
1319
1320   /* Use the cp15 method if it is available.  */
1321   if (target_thread_pointer == TP_AUTO)
1322     {
1323       if (arm_arch6k && !TARGET_THUMB)
1324         target_thread_pointer = TP_CP15;
1325       else
1326         target_thread_pointer = TP_SOFT;
1327     }
1328
1329   if (TARGET_HARD_TP && TARGET_THUMB1)
1330     error ("can not use -mtp=cp15 with 16-bit Thumb");
1331
1332   /* Override the default structure alignment for AAPCS ABI.  */
1333   if (TARGET_AAPCS_BASED)
1334     arm_structure_size_boundary = 8;
1335
1336   if (structure_size_string != NULL)
1337     {
1338       int size = strtol (structure_size_string, NULL, 0);
1339
1340       if (size == 8 || size == 32
1341           || (ARM_DOUBLEWORD_ALIGN && size == 64))
1342         arm_structure_size_boundary = size;
1343       else
1344         warning (0, "structure size boundary can only be set to %s",
1345                  ARM_DOUBLEWORD_ALIGN ? "8, 32 or 64": "8 or 32");
1346     }
1347
1348   if (!TARGET_ARM && TARGET_VXWORKS_RTP && flag_pic)
1349     {
1350       error ("RTP PIC is incompatible with Thumb");
1351       flag_pic = 0;
1352     }
1353
1354   /* If stack checking is disabled, we can use r10 as the PIC register,
1355      which keeps r9 available.  The EABI specifies r9 as the PIC register.  */
1356   if (flag_pic && TARGET_SINGLE_PIC_BASE)
1357     {
1358       if (TARGET_VXWORKS_RTP)
1359         warning (0, "RTP PIC is incompatible with -msingle-pic-base");
1360       arm_pic_register = (TARGET_APCS_STACK || TARGET_AAPCS_BASED) ? 9 : 10;
1361     }
1362
1363   if (flag_pic && TARGET_VXWORKS_RTP)
1364     arm_pic_register = 9;
1365
1366   if (arm_pic_register_string != NULL)
1367     {
1368       int pic_register = decode_reg_name (arm_pic_register_string);
1369
1370       if (!flag_pic)
1371         warning (0, "-mpic-register= is useless without -fpic");
1372
1373       /* Prevent the user from choosing an obviously stupid PIC register.  */
1374       else if (pic_register < 0 || call_used_regs[pic_register]
1375                || pic_register == HARD_FRAME_POINTER_REGNUM
1376                || pic_register == STACK_POINTER_REGNUM
1377                || pic_register >= PC_REGNUM
1378                || (TARGET_VXWORKS_RTP
1379                    && (unsigned int) pic_register != arm_pic_register))
1380         error ("unable to use '%s' for PIC register", arm_pic_register_string);
1381       else
1382         arm_pic_register = pic_register;
1383     }
1384
1385   /* ??? We might want scheduling for thumb2.  */
1386   if (TARGET_THUMB && flag_schedule_insns)
1387     {
1388       /* Don't warn since it's on by default in -O2.  */
1389       flag_schedule_insns = 0;
1390     }
1391
1392   if (optimize_size)
1393     {
1394       arm_constant_limit = 1;
1395
1396       /* If optimizing for size, bump the number of instructions that we
1397          are prepared to conditionally execute (even on a StrongARM).  */
1398       max_insns_skipped = 6;
1399     }
1400   else
1401     {
1402       /* For processors with load scheduling, it never costs more than
1403          2 cycles to load a constant, and the load scheduler may well
1404          reduce that to 1.  */
1405       if (arm_ld_sched)
1406         arm_constant_limit = 1;
1407
1408       /* On XScale the longer latency of a load makes it more difficult
1409          to achieve a good schedule, so it's faster to synthesize
1410          constants that can be done in two insns.  */
1411       if (arm_tune_xscale)
1412         arm_constant_limit = 2;
1413
1414       /* StrongARM has early execution of branches, so a sequence
1415          that is worth skipping is shorter.  */
1416       if (arm_tune_strongarm)
1417         max_insns_skipped = 3;
1418     }
1419
1420   /* Register global variables with the garbage collector.  */
1421   arm_add_gc_roots ();
1422 }
1423
1424 static void
1425 arm_add_gc_roots (void)
1426 {
1427   gcc_obstack_init(&minipool_obstack);
1428   minipool_startobj = (char *) obstack_alloc (&minipool_obstack, 0);
1429 }
1430 \f
1431 /* A table of known ARM exception types.
1432    For use with the interrupt function attribute.  */
1433
1434 typedef struct
1435 {
1436   const char *const arg;
1437   const unsigned long return_value;
1438 }
1439 isr_attribute_arg;
1440
1441 static const isr_attribute_arg isr_attribute_args [] =
1442 {
1443   { "IRQ",   ARM_FT_ISR },
1444   { "irq",   ARM_FT_ISR },
1445   { "FIQ",   ARM_FT_FIQ },
1446   { "fiq",   ARM_FT_FIQ },
1447   { "ABORT", ARM_FT_ISR },
1448   { "abort", ARM_FT_ISR },
1449   { "ABORT", ARM_FT_ISR },
1450   { "abort", ARM_FT_ISR },
1451   { "UNDEF", ARM_FT_EXCEPTION },
1452   { "undef", ARM_FT_EXCEPTION },
1453   { "SWI",   ARM_FT_EXCEPTION },
1454   { "swi",   ARM_FT_EXCEPTION },
1455   { NULL,    ARM_FT_NORMAL }
1456 };
1457
1458 /* Returns the (interrupt) function type of the current
1459    function, or ARM_FT_UNKNOWN if the type cannot be determined.  */
1460
1461 static unsigned long
1462 arm_isr_value (tree argument)
1463 {
1464   const isr_attribute_arg * ptr;
1465   const char *              arg;
1466
1467   if (!arm_arch_notm)
1468     return ARM_FT_NORMAL | ARM_FT_STACKALIGN;
1469
1470   /* No argument - default to IRQ.  */
1471   if (argument == NULL_TREE)
1472     return ARM_FT_ISR;
1473
1474   /* Get the value of the argument.  */
1475   if (TREE_VALUE (argument) == NULL_TREE
1476       || TREE_CODE (TREE_VALUE (argument)) != STRING_CST)
1477     return ARM_FT_UNKNOWN;
1478
1479   arg = TREE_STRING_POINTER (TREE_VALUE (argument));
1480
1481   /* Check it against the list of known arguments.  */
1482   for (ptr = isr_attribute_args; ptr->arg != NULL; ptr++)
1483     if (streq (arg, ptr->arg))
1484       return ptr->return_value;
1485
1486   /* An unrecognized interrupt type.  */
1487   return ARM_FT_UNKNOWN;
1488 }
1489
1490 /* Computes the type of the current function.  */
1491
1492 static unsigned long
1493 arm_compute_func_type (void)
1494 {
1495   unsigned long type = ARM_FT_UNKNOWN;
1496   tree a;
1497   tree attr;
1498
1499   gcc_assert (TREE_CODE (current_function_decl) == FUNCTION_DECL);
1500
1501   /* Decide if the current function is volatile.  Such functions
1502      never return, and many memory cycles can be saved by not storing
1503      register values that will never be needed again.  This optimization
1504      was added to speed up context switching in a kernel application.  */
1505   if (optimize > 0
1506       && (TREE_NOTHROW (current_function_decl)
1507           || !(flag_unwind_tables
1508                || (flag_exceptions && !USING_SJLJ_EXCEPTIONS)))
1509       && TREE_THIS_VOLATILE (current_function_decl))
1510     type |= ARM_FT_VOLATILE;
1511
1512   if (cfun->static_chain_decl != NULL)
1513     type |= ARM_FT_NESTED;
1514
1515   attr = DECL_ATTRIBUTES (current_function_decl);
1516
1517   a = lookup_attribute ("naked", attr);
1518   if (a != NULL_TREE)
1519     type |= ARM_FT_NAKED;
1520
1521   a = lookup_attribute ("isr", attr);
1522   if (a == NULL_TREE)
1523     a = lookup_attribute ("interrupt", attr);
1524
1525   if (a == NULL_TREE)
1526     type |= TARGET_INTERWORK ? ARM_FT_INTERWORKED : ARM_FT_NORMAL;
1527   else
1528     type |= arm_isr_value (TREE_VALUE (a));
1529
1530   return type;
1531 }
1532
1533 /* Returns the type of the current function.  */
1534
1535 unsigned long
1536 arm_current_func_type (void)
1537 {
1538   if (ARM_FUNC_TYPE (cfun->machine->func_type) == ARM_FT_UNKNOWN)
1539     cfun->machine->func_type = arm_compute_func_type ();
1540
1541   return cfun->machine->func_type;
1542 }
1543 \f
1544 /* Return 1 if it is possible to return using a single instruction.
1545    If SIBLING is non-null, this is a test for a return before a sibling
1546    call.  SIBLING is the call insn, so we can examine its register usage.  */
1547
1548 int
1549 use_return_insn (int iscond, rtx sibling)
1550 {
1551   int regno;
1552   unsigned int func_type;
1553   unsigned long saved_int_regs;
1554   unsigned HOST_WIDE_INT stack_adjust;
1555   arm_stack_offsets *offsets;
1556
1557   /* Never use a return instruction before reload has run.  */
1558   if (!reload_completed)
1559     return 0;
1560
1561   func_type = arm_current_func_type ();
1562
1563   /* Naked, volatile and stack alignment functions need special
1564      consideration.  */
1565   if (func_type & (ARM_FT_VOLATILE | ARM_FT_NAKED | ARM_FT_STACKALIGN))
1566     return 0;
1567
1568   /* So do interrupt functions that use the frame pointer and Thumb
1569      interrupt functions.  */
1570   if (IS_INTERRUPT (func_type) && (frame_pointer_needed || TARGET_THUMB))
1571     return 0;
1572
1573   offsets = arm_get_frame_offsets ();
1574   stack_adjust = offsets->outgoing_args - offsets->saved_regs;
1575
1576   /* As do variadic functions.  */
1577   if (current_function_pretend_args_size
1578       || cfun->machine->uses_anonymous_args
1579       /* Or if the function calls __builtin_eh_return () */
1580       || current_function_calls_eh_return
1581       /* Or if the function calls alloca */
1582       || current_function_calls_alloca
1583       /* Or if there is a stack adjustment.  However, if the stack pointer
1584          is saved on the stack, we can use a pre-incrementing stack load.  */
1585       || !(stack_adjust == 0 || (frame_pointer_needed && stack_adjust == 4)))
1586     return 0;
1587
1588   saved_int_regs = arm_compute_save_reg_mask ();
1589
1590   /* Unfortunately, the insn
1591
1592        ldmib sp, {..., sp, ...}
1593
1594      triggers a bug on most SA-110 based devices, such that the stack
1595      pointer won't be correctly restored if the instruction takes a
1596      page fault.  We work around this problem by popping r3 along with
1597      the other registers, since that is never slower than executing
1598      another instruction.
1599
1600      We test for !arm_arch5 here, because code for any architecture
1601      less than this could potentially be run on one of the buggy
1602      chips.  */
1603   if (stack_adjust == 4 && !arm_arch5 && TARGET_ARM)
1604     {
1605       /* Validate that r3 is a call-clobbered register (always true in
1606          the default abi) ...  */
1607       if (!call_used_regs[3])
1608         return 0;
1609
1610       /* ... that it isn't being used for a return value ... */
1611       if (arm_size_return_regs () >= (4 * UNITS_PER_WORD))
1612         return 0;
1613
1614       /* ... or for a tail-call argument ...  */
1615       if (sibling)
1616         {
1617           gcc_assert (GET_CODE (sibling) == CALL_INSN);
1618
1619           if (find_regno_fusage (sibling, USE, 3))
1620             return 0;
1621         }
1622
1623       /* ... and that there are no call-saved registers in r0-r2
1624          (always true in the default ABI).  */
1625       if (saved_int_regs & 0x7)
1626         return 0;
1627     }
1628
1629   /* Can't be done if interworking with Thumb, and any registers have been
1630      stacked.  */
1631   if (TARGET_INTERWORK && saved_int_regs != 0 && !IS_INTERRUPT(func_type))
1632     return 0;
1633
1634   /* On StrongARM, conditional returns are expensive if they aren't
1635      taken and multiple registers have been stacked.  */
1636   if (iscond && arm_tune_strongarm)
1637     {
1638       /* Conditional return when just the LR is stored is a simple
1639          conditional-load instruction, that's not expensive.  */
1640       if (saved_int_regs != 0 && saved_int_regs != (1 << LR_REGNUM))
1641         return 0;
1642
1643       if (flag_pic 
1644           && arm_pic_register != INVALID_REGNUM
1645           && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM))
1646         return 0;
1647     }
1648
1649   /* If there are saved registers but the LR isn't saved, then we need
1650      two instructions for the return.  */
1651   if (saved_int_regs && !(saved_int_regs & (1 << LR_REGNUM)))
1652     return 0;
1653
1654   /* Can't be done if any of the FPA regs are pushed,
1655      since this also requires an insn.  */
1656   if (TARGET_HARD_FLOAT && TARGET_FPA)
1657     for (regno = FIRST_FPA_REGNUM; regno <= LAST_FPA_REGNUM; regno++)
1658       if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
1659         return 0;
1660
1661   /* Likewise VFP regs.  */
1662   if (TARGET_HARD_FLOAT && TARGET_VFP)
1663     for (regno = FIRST_VFP_REGNUM; regno <= LAST_VFP_REGNUM; regno++)
1664       if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
1665         return 0;
1666
1667   if (TARGET_REALLY_IWMMXT)
1668     for (regno = FIRST_IWMMXT_REGNUM; regno <= LAST_IWMMXT_REGNUM; regno++)
1669       if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
1670         return 0;
1671
1672   return 1;
1673 }
1674
1675 /* Return TRUE if int I is a valid immediate ARM constant.  */
1676
1677 int
1678 const_ok_for_arm (HOST_WIDE_INT i)
1679 {
1680   int lowbit;
1681
1682   /* For machines with >32 bit HOST_WIDE_INT, the bits above bit 31 must
1683      be all zero, or all one.  */
1684   if ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff) != 0
1685       && ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff)
1686           != ((~(unsigned HOST_WIDE_INT) 0)
1687               & ~(unsigned HOST_WIDE_INT) 0xffffffff)))
1688     return FALSE;
1689
1690   i &= (unsigned HOST_WIDE_INT) 0xffffffff;
1691
1692   /* Fast return for 0 and small values.  We must do this for zero, since
1693      the code below can't handle that one case.  */
1694   if ((i & ~(unsigned HOST_WIDE_INT) 0xff) == 0)
1695     return TRUE;
1696
1697   /* Get the number of trailing zeros.  */
1698   lowbit = ffs((int) i) - 1;
1699   
1700   /* Only even shifts are allowed in ARM mode so round down to the
1701      nearest even number.  */
1702   if (TARGET_ARM)
1703     lowbit &= ~1;
1704
1705   if ((i & ~(((unsigned HOST_WIDE_INT) 0xff) << lowbit)) == 0)
1706     return TRUE;
1707
1708   if (TARGET_ARM)
1709     {
1710       /* Allow rotated constants in ARM mode.  */
1711       if (lowbit <= 4
1712            && ((i & ~0xc000003f) == 0
1713                || (i & ~0xf000000f) == 0
1714                || (i & ~0xfc000003) == 0))
1715         return TRUE;
1716     }
1717   else
1718     {
1719       HOST_WIDE_INT v;
1720
1721       /* Allow repeated pattern.  */
1722       v = i & 0xff;
1723       v |= v << 16;
1724       if (i == v || i == (v | (v << 8)))
1725         return TRUE;
1726     }
1727
1728   return FALSE;
1729 }
1730
1731 /* Return true if I is a valid constant for the operation CODE.  */
1732 static int
1733 const_ok_for_op (HOST_WIDE_INT i, enum rtx_code code)
1734 {
1735   if (const_ok_for_arm (i))
1736     return 1;
1737
1738   switch (code)
1739     {
1740     case PLUS:
1741       return const_ok_for_arm (ARM_SIGN_EXTEND (-i));
1742
1743     case MINUS:         /* Should only occur with (MINUS I reg) => rsb */
1744     case XOR:
1745     case IOR:
1746       return 0;
1747
1748     case AND:
1749       return const_ok_for_arm (ARM_SIGN_EXTEND (~i));
1750
1751     default:
1752       gcc_unreachable ();
1753     }
1754 }
1755
1756 /* Emit a sequence of insns to handle a large constant.
1757    CODE is the code of the operation required, it can be any of SET, PLUS,
1758    IOR, AND, XOR, MINUS;
1759    MODE is the mode in which the operation is being performed;
1760    VAL is the integer to operate on;
1761    SOURCE is the other operand (a register, or a null-pointer for SET);
1762    SUBTARGETS means it is safe to create scratch registers if that will
1763    either produce a simpler sequence, or we will want to cse the values.
1764    Return value is the number of insns emitted.  */
1765
1766 /* ??? Tweak this for thumb2.  */
1767 int
1768 arm_split_constant (enum rtx_code code, enum machine_mode mode, rtx insn,
1769                     HOST_WIDE_INT val, rtx target, rtx source, int subtargets)
1770 {
1771   rtx cond;
1772
1773   if (insn && GET_CODE (PATTERN (insn)) == COND_EXEC)
1774     cond = COND_EXEC_TEST (PATTERN (insn));
1775   else
1776     cond = NULL_RTX;
1777
1778   if (subtargets || code == SET
1779       || (GET_CODE (target) == REG && GET_CODE (source) == REG
1780           && REGNO (target) != REGNO (source)))
1781     {
1782       /* After arm_reorg has been called, we can't fix up expensive
1783          constants by pushing them into memory so we must synthesize
1784          them in-line, regardless of the cost.  This is only likely to
1785          be more costly on chips that have load delay slots and we are
1786          compiling without running the scheduler (so no splitting
1787          occurred before the final instruction emission).
1788
1789          Ref: gcc -O1 -mcpu=strongarm gcc.c-torture/compile/980506-2.c
1790       */
1791       if (!after_arm_reorg
1792           && !cond
1793           && (arm_gen_constant (code, mode, NULL_RTX, val, target, source,
1794                                 1, 0)
1795               > arm_constant_limit + (code != SET)))
1796         {
1797           if (code == SET)
1798             {
1799               /* Currently SET is the only monadic value for CODE, all
1800                  the rest are diadic.  */
1801               emit_set_insn (target, GEN_INT (val));
1802               return 1;
1803             }
1804           else
1805             {
1806               rtx temp = subtargets ? gen_reg_rtx (mode) : target;
1807
1808               emit_set_insn (temp, GEN_INT (val));
1809               /* For MINUS, the value is subtracted from, since we never
1810                  have subtraction of a constant.  */
1811               if (code == MINUS)
1812                 emit_set_insn (target, gen_rtx_MINUS (mode, temp, source));
1813               else
1814                 emit_set_insn (target,
1815                                gen_rtx_fmt_ee (code, mode, source, temp));
1816               return 2;
1817             }
1818         }
1819     }
1820
1821   return arm_gen_constant (code, mode, cond, val, target, source, subtargets,
1822                            1);
1823 }
1824
1825 /* Return the number of ARM instructions required to synthesize the given
1826    constant.  */
1827 static int
1828 count_insns_for_constant (HOST_WIDE_INT remainder, int i)
1829 {
1830   HOST_WIDE_INT temp1;
1831   int num_insns = 0;
1832   do
1833     {
1834       int end;
1835
1836       if (i <= 0)
1837         i += 32;
1838       if (remainder & (3 << (i - 2)))
1839         {
1840           end = i - 8;
1841           if (end < 0)
1842             end += 32;
1843           temp1 = remainder & ((0x0ff << end)
1844                                     | ((i < end) ? (0xff >> (32 - end)) : 0));
1845           remainder &= ~temp1;
1846           num_insns++;
1847           i -= 6;
1848         }
1849       i -= 2;
1850     } while (remainder);
1851   return num_insns;
1852 }
1853
1854 /* Emit an instruction with the indicated PATTERN.  If COND is
1855    non-NULL, conditionalize the execution of the instruction on COND
1856    being true.  */
1857
1858 static void
1859 emit_constant_insn (rtx cond, rtx pattern)
1860 {
1861   if (cond)
1862     pattern = gen_rtx_COND_EXEC (VOIDmode, copy_rtx (cond), pattern);
1863   emit_insn (pattern);
1864 }
1865
1866 /* As above, but extra parameter GENERATE which, if clear, suppresses
1867    RTL generation.  */
1868 /* ??? This needs more work for thumb2.  */
1869
1870 static int
1871 arm_gen_constant (enum rtx_code code, enum machine_mode mode, rtx cond,
1872                   HOST_WIDE_INT val, rtx target, rtx source, int subtargets,
1873                   int generate)
1874 {
1875   int can_invert = 0;
1876   int can_negate = 0;
1877   int can_negate_initial = 0;
1878   int can_shift = 0;
1879   int i;
1880   int num_bits_set = 0;
1881   int set_sign_bit_copies = 0;
1882   int clear_sign_bit_copies = 0;
1883   int clear_zero_bit_copies = 0;
1884   int set_zero_bit_copies = 0;
1885   int insns = 0;
1886   unsigned HOST_WIDE_INT temp1, temp2;
1887   unsigned HOST_WIDE_INT remainder = val & 0xffffffff;
1888
1889   /* Find out which operations are safe for a given CODE.  Also do a quick
1890      check for degenerate cases; these can occur when DImode operations
1891      are split.  */
1892   switch (code)
1893     {
1894     case SET:
1895       can_invert = 1;
1896       can_shift = 1;
1897       can_negate = 1;
1898       break;
1899
1900     case PLUS:
1901       can_negate = 1;
1902       can_negate_initial = 1;
1903       break;
1904
1905     case IOR:
1906       if (remainder == 0xffffffff)
1907         {
1908           if (generate)
1909             emit_constant_insn (cond,
1910                                 gen_rtx_SET (VOIDmode, target,
1911                                              GEN_INT (ARM_SIGN_EXTEND (val))));
1912           return 1;
1913         }
1914       if (remainder == 0)
1915         {
1916           if (reload_completed && rtx_equal_p (target, source))
1917             return 0;
1918           if (generate)
1919             emit_constant_insn (cond,
1920                                 gen_rtx_SET (VOIDmode, target, source));
1921           return 1;
1922         }
1923       break;
1924
1925     case AND:
1926       if (remainder == 0)
1927         {
1928           if (generate)
1929             emit_constant_insn (cond,
1930                                 gen_rtx_SET (VOIDmode, target, const0_rtx));
1931           return 1;
1932         }
1933       if (remainder == 0xffffffff)
1934         {
1935           if (reload_completed && rtx_equal_p (target, source))
1936             return 0;
1937           if (generate)
1938             emit_constant_insn (cond,
1939                                 gen_rtx_SET (VOIDmode, target, source));
1940           return 1;
1941         }
1942       can_invert = 1;
1943       break;
1944
1945     case XOR:
1946       if (remainder == 0)
1947         {
1948           if (reload_completed && rtx_equal_p (target, source))
1949             return 0;
1950           if (generate)
1951             emit_constant_insn (cond,
1952                                 gen_rtx_SET (VOIDmode, target, source));
1953           return 1;
1954         }
1955
1956       /* We don't know how to handle other cases yet.  */
1957       gcc_assert (remainder == 0xffffffff);
1958
1959       if (generate)
1960         emit_constant_insn (cond,
1961                             gen_rtx_SET (VOIDmode, target,
1962                                          gen_rtx_NOT (mode, source)));
1963       return 1;
1964
1965     case MINUS:
1966       /* We treat MINUS as (val - source), since (source - val) is always
1967          passed as (source + (-val)).  */
1968       if (remainder == 0)
1969         {
1970           if (generate)
1971             emit_constant_insn (cond,
1972                                 gen_rtx_SET (VOIDmode, target,
1973                                              gen_rtx_NEG (mode, source)));
1974           return 1;
1975         }
1976       if (const_ok_for_arm (val))
1977         {
1978           if (generate)
1979             emit_constant_insn (cond,
1980                                 gen_rtx_SET (VOIDmode, target,
1981                                              gen_rtx_MINUS (mode, GEN_INT (val),
1982                                                             source)));
1983           return 1;
1984         }
1985       can_negate = 1;
1986
1987       break;
1988
1989     default:
1990       gcc_unreachable ();
1991     }
1992
1993   /* If we can do it in one insn get out quickly.  */
1994   if (const_ok_for_arm (val)
1995       || (can_negate_initial && const_ok_for_arm (-val))
1996       || (can_invert && const_ok_for_arm (~val)))
1997     {
1998       if (generate)
1999         emit_constant_insn (cond,
2000                             gen_rtx_SET (VOIDmode, target,
2001                                          (source
2002                                           ? gen_rtx_fmt_ee (code, mode, source,
2003                                                             GEN_INT (val))
2004                                           : GEN_INT (val))));
2005       return 1;
2006     }
2007
2008   /* Calculate a few attributes that may be useful for specific
2009      optimizations.  */
2010   for (i = 31; i >= 0; i--)
2011     {
2012       if ((remainder & (1 << i)) == 0)
2013         clear_sign_bit_copies++;
2014       else
2015         break;
2016     }
2017
2018   for (i = 31; i >= 0; i--)
2019     {
2020       if ((remainder & (1 << i)) != 0)
2021         set_sign_bit_copies++;
2022       else
2023         break;
2024     }
2025
2026   for (i = 0; i <= 31; i++)
2027     {
2028       if ((remainder & (1 << i)) == 0)
2029         clear_zero_bit_copies++;
2030       else
2031         break;
2032     }
2033
2034   for (i = 0; i <= 31; i++)
2035     {
2036       if ((remainder & (1 << i)) != 0)
2037         set_zero_bit_copies++;
2038       else
2039         break;
2040     }
2041
2042   switch (code)
2043     {
2044     case SET:
2045       /* See if we can use movw.  */
2046       if (arm_arch_thumb2 && (remainder & 0xffff0000) == 0)
2047         {
2048           if (generate)
2049             emit_constant_insn (cond, gen_rtx_SET (VOIDmode, target,
2050                                                    GEN_INT (val)));
2051           return 1;
2052         }
2053
2054       /* See if we can do this by sign_extending a constant that is known
2055          to be negative.  This is a good, way of doing it, since the shift
2056          may well merge into a subsequent insn.  */
2057       if (set_sign_bit_copies > 1)
2058         {
2059           if (const_ok_for_arm
2060               (temp1 = ARM_SIGN_EXTEND (remainder
2061                                         << (set_sign_bit_copies - 1))))
2062             {
2063               if (generate)
2064                 {
2065                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2066                   emit_constant_insn (cond,
2067                                       gen_rtx_SET (VOIDmode, new_src,
2068                                                    GEN_INT (temp1)));
2069                   emit_constant_insn (cond,
2070                                       gen_ashrsi3 (target, new_src,
2071                                                    GEN_INT (set_sign_bit_copies - 1)));
2072                 }
2073               return 2;
2074             }
2075           /* For an inverted constant, we will need to set the low bits,
2076              these will be shifted out of harm's way.  */
2077           temp1 |= (1 << (set_sign_bit_copies - 1)) - 1;
2078           if (const_ok_for_arm (~temp1))
2079             {
2080               if (generate)
2081                 {
2082                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2083                   emit_constant_insn (cond,
2084                                       gen_rtx_SET (VOIDmode, new_src,
2085                                                    GEN_INT (temp1)));
2086                   emit_constant_insn (cond,
2087                                       gen_ashrsi3 (target, new_src,
2088                                                    GEN_INT (set_sign_bit_copies - 1)));
2089                 }
2090               return 2;
2091             }
2092         }
2093
2094       /* See if we can calculate the value as the difference between two
2095          valid immediates.  */
2096       if (clear_sign_bit_copies + clear_zero_bit_copies <= 16)
2097         {
2098           int topshift = clear_sign_bit_copies & ~1;
2099
2100           temp1 = ARM_SIGN_EXTEND ((remainder + (0x00800000 >> topshift))
2101                                    & (0xff000000 >> topshift));
2102
2103           /* If temp1 is zero, then that means the 9 most significant
2104              bits of remainder were 1 and we've caused it to overflow.
2105              When topshift is 0 we don't need to do anything since we
2106              can borrow from 'bit 32'.  */
2107           if (temp1 == 0 && topshift != 0)
2108             temp1 = 0x80000000 >> (topshift - 1);
2109
2110           temp2 = ARM_SIGN_EXTEND (temp1 - remainder);
2111
2112           if (const_ok_for_arm (temp2))
2113             {
2114               if (generate)
2115                 {
2116                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2117                   emit_constant_insn (cond,
2118                                       gen_rtx_SET (VOIDmode, new_src,
2119                                                    GEN_INT (temp1)));
2120                   emit_constant_insn (cond,
2121                                       gen_addsi3 (target, new_src,
2122                                                   GEN_INT (-temp2)));
2123                 }
2124
2125               return 2;
2126             }
2127         }
2128
2129       /* See if we can generate this by setting the bottom (or the top)
2130          16 bits, and then shifting these into the other half of the
2131          word.  We only look for the simplest cases, to do more would cost
2132          too much.  Be careful, however, not to generate this when the
2133          alternative would take fewer insns.  */
2134       if (val & 0xffff0000)
2135         {
2136           temp1 = remainder & 0xffff0000;
2137           temp2 = remainder & 0x0000ffff;
2138
2139           /* Overlaps outside this range are best done using other methods.  */
2140           for (i = 9; i < 24; i++)
2141             {
2142               if ((((temp2 | (temp2 << i)) & 0xffffffff) == remainder)
2143                   && !const_ok_for_arm (temp2))
2144                 {
2145                   rtx new_src = (subtargets
2146                                  ? (generate ? gen_reg_rtx (mode) : NULL_RTX)
2147                                  : target);
2148                   insns = arm_gen_constant (code, mode, cond, temp2, new_src,
2149                                             source, subtargets, generate);
2150                   source = new_src;
2151                   if (generate)
2152                     emit_constant_insn
2153                       (cond,
2154                        gen_rtx_SET
2155                        (VOIDmode, target,
2156                         gen_rtx_IOR (mode,
2157                                      gen_rtx_ASHIFT (mode, source,
2158                                                      GEN_INT (i)),
2159                                      source)));
2160                   return insns + 1;
2161                 }
2162             }
2163
2164           /* Don't duplicate cases already considered.  */
2165           for (i = 17; i < 24; i++)
2166             {
2167               if (((temp1 | (temp1 >> i)) == remainder)
2168                   && !const_ok_for_arm (temp1))
2169                 {
2170                   rtx new_src = (subtargets
2171                                  ? (generate ? gen_reg_rtx (mode) : NULL_RTX)
2172                                  : target);
2173                   insns = arm_gen_constant (code, mode, cond, temp1, new_src,
2174                                             source, subtargets, generate);
2175                   source = new_src;
2176                   if (generate)
2177                     emit_constant_insn
2178                       (cond,
2179                        gen_rtx_SET (VOIDmode, target,
2180                                     gen_rtx_IOR
2181                                     (mode,
2182                                      gen_rtx_LSHIFTRT (mode, source,
2183                                                        GEN_INT (i)),
2184                                      source)));
2185                   return insns + 1;
2186                 }
2187             }
2188         }
2189       break;
2190
2191     case IOR:
2192     case XOR:
2193       /* If we have IOR or XOR, and the constant can be loaded in a
2194          single instruction, and we can find a temporary to put it in,
2195          then this can be done in two instructions instead of 3-4.  */
2196       if (subtargets
2197           /* TARGET can't be NULL if SUBTARGETS is 0 */
2198           || (reload_completed && !reg_mentioned_p (target, source)))
2199         {
2200           if (const_ok_for_arm (ARM_SIGN_EXTEND (~val)))
2201             {
2202               if (generate)
2203                 {
2204                   rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2205
2206                   emit_constant_insn (cond,
2207                                       gen_rtx_SET (VOIDmode, sub,
2208                                                    GEN_INT (val)));
2209                   emit_constant_insn (cond,
2210                                       gen_rtx_SET (VOIDmode, target,
2211                                                    gen_rtx_fmt_ee (code, mode,
2212                                                                    source, sub)));
2213                 }
2214               return 2;
2215             }
2216         }
2217
2218       if (code == XOR)
2219         break;
2220
2221       if (set_sign_bit_copies > 8
2222           && (val & (-1 << (32 - set_sign_bit_copies))) == val)
2223         {
2224           if (generate)
2225             {
2226               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2227               rtx shift = GEN_INT (set_sign_bit_copies);
2228
2229               emit_constant_insn
2230                 (cond,
2231                  gen_rtx_SET (VOIDmode, sub,
2232                               gen_rtx_NOT (mode,
2233                                            gen_rtx_ASHIFT (mode,
2234                                                            source,
2235                                                            shift))));
2236               emit_constant_insn
2237                 (cond,
2238                  gen_rtx_SET (VOIDmode, target,
2239                               gen_rtx_NOT (mode,
2240                                            gen_rtx_LSHIFTRT (mode, sub,
2241                                                              shift))));
2242             }
2243           return 2;
2244         }
2245
2246       if (set_zero_bit_copies > 8
2247           && (remainder & ((1 << set_zero_bit_copies) - 1)) == remainder)
2248         {
2249           if (generate)
2250             {
2251               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2252               rtx shift = GEN_INT (set_zero_bit_copies);
2253
2254               emit_constant_insn
2255                 (cond,
2256                  gen_rtx_SET (VOIDmode, sub,
2257                               gen_rtx_NOT (mode,
2258                                            gen_rtx_LSHIFTRT (mode,
2259                                                              source,
2260                                                              shift))));
2261               emit_constant_insn
2262                 (cond,
2263                  gen_rtx_SET (VOIDmode, target,
2264                               gen_rtx_NOT (mode,
2265                                            gen_rtx_ASHIFT (mode, sub,
2266                                                            shift))));
2267             }
2268           return 2;
2269         }
2270
2271       if (const_ok_for_arm (temp1 = ARM_SIGN_EXTEND (~val)))
2272         {
2273           if (generate)
2274             {
2275               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
2276               emit_constant_insn (cond,
2277                                   gen_rtx_SET (VOIDmode, sub,
2278                                                gen_rtx_NOT (mode, source)));
2279               source = sub;
2280               if (subtargets)
2281                 sub = gen_reg_rtx (mode);
2282               emit_constant_insn (cond,
2283                                   gen_rtx_SET (VOIDmode, sub,
2284                                                gen_rtx_AND (mode, source,
2285                                                             GEN_INT (temp1))));
2286               emit_constant_insn (cond,
2287                                   gen_rtx_SET (VOIDmode, target,
2288                                                gen_rtx_NOT (mode, sub)));
2289             }
2290           return 3;
2291         }
2292       break;
2293
2294     case AND:
2295       /* See if two shifts will do 2 or more insn's worth of work.  */
2296       if (clear_sign_bit_copies >= 16 && clear_sign_bit_copies < 24)
2297         {
2298           HOST_WIDE_INT shift_mask = ((0xffffffff
2299                                        << (32 - clear_sign_bit_copies))
2300                                       & 0xffffffff);
2301
2302           if ((remainder | shift_mask) != 0xffffffff)
2303             {
2304               if (generate)
2305                 {
2306                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2307                   insns = arm_gen_constant (AND, mode, cond,
2308                                             remainder | shift_mask,
2309                                             new_src, source, subtargets, 1);
2310                   source = new_src;
2311                 }
2312               else
2313                 {
2314                   rtx targ = subtargets ? NULL_RTX : target;
2315                   insns = arm_gen_constant (AND, mode, cond,
2316                                             remainder | shift_mask,
2317                                             targ, source, subtargets, 0);
2318                 }
2319             }
2320
2321           if (generate)
2322             {
2323               rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2324               rtx shift = GEN_INT (clear_sign_bit_copies);
2325
2326               emit_insn (gen_ashlsi3 (new_src, source, shift));
2327               emit_insn (gen_lshrsi3 (target, new_src, shift));
2328             }
2329
2330           return insns + 2;
2331         }
2332
2333       if (clear_zero_bit_copies >= 16 && clear_zero_bit_copies < 24)
2334         {
2335           HOST_WIDE_INT shift_mask = (1 << clear_zero_bit_copies) - 1;
2336
2337           if ((remainder | shift_mask) != 0xffffffff)
2338             {
2339               if (generate)
2340                 {
2341                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2342
2343                   insns = arm_gen_constant (AND, mode, cond,
2344                                             remainder | shift_mask,
2345                                             new_src, source, subtargets, 1);
2346                   source = new_src;
2347                 }
2348               else
2349                 {
2350                   rtx targ = subtargets ? NULL_RTX : target;
2351
2352                   insns = arm_gen_constant (AND, mode, cond,
2353                                             remainder | shift_mask,
2354                                             targ, source, subtargets, 0);
2355                 }
2356             }
2357
2358           if (generate)
2359             {
2360               rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2361               rtx shift = GEN_INT (clear_zero_bit_copies);
2362
2363               emit_insn (gen_lshrsi3 (new_src, source, shift));
2364               emit_insn (gen_ashlsi3 (target, new_src, shift));
2365             }
2366
2367           return insns + 2;
2368         }
2369
2370       break;
2371
2372     default:
2373       break;
2374     }
2375
2376   for (i = 0; i < 32; i++)
2377     if (remainder & (1 << i))
2378       num_bits_set++;
2379
2380   if (code == AND || (can_invert && num_bits_set > 16))
2381     remainder = (~remainder) & 0xffffffff;
2382   else if (code == PLUS && num_bits_set > 16)
2383     remainder = (-remainder) & 0xffffffff;
2384   else
2385     {
2386       can_invert = 0;
2387       can_negate = 0;
2388     }
2389
2390   /* Now try and find a way of doing the job in either two or three
2391      instructions.
2392      We start by looking for the largest block of zeros that are aligned on
2393      a 2-bit boundary, we then fill up the temps, wrapping around to the
2394      top of the word when we drop off the bottom.
2395      In the worst case this code should produce no more than four insns.
2396      Thumb-2 constants are shifted, not rotated, so the MSB is always the
2397      best place to start.  */
2398
2399   /* ??? Use thumb2 replicated constants when the high and low halfwords are
2400      the same.  */
2401   {
2402     int best_start = 0;
2403     if (!TARGET_THUMB2)
2404       {
2405         int best_consecutive_zeros = 0;
2406
2407         for (i = 0; i < 32; i += 2)
2408           {
2409             int consecutive_zeros = 0;
2410
2411             if (!(remainder & (3 << i)))
2412               {
2413                 while ((i < 32) && !(remainder & (3 << i)))
2414                   {
2415                     consecutive_zeros += 2;
2416                     i += 2;
2417                   }
2418                 if (consecutive_zeros > best_consecutive_zeros)
2419                   {
2420                     best_consecutive_zeros = consecutive_zeros;
2421                     best_start = i - consecutive_zeros;
2422                   }
2423                 i -= 2;
2424               }
2425           }
2426
2427         /* So long as it won't require any more insns to do so, it's
2428            desirable to emit a small constant (in bits 0...9) in the last
2429            insn.  This way there is more chance that it can be combined with
2430            a later addressing insn to form a pre-indexed load or store
2431            operation.  Consider:
2432
2433                    *((volatile int *)0xe0000100) = 1;
2434                    *((volatile int *)0xe0000110) = 2;
2435
2436            We want this to wind up as:
2437
2438                     mov rA, #0xe0000000
2439                     mov rB, #1
2440                     str rB, [rA, #0x100]
2441                     mov rB, #2
2442                     str rB, [rA, #0x110]
2443
2444            rather than having to synthesize both large constants from scratch.
2445
2446            Therefore, we calculate how many insns would be required to emit
2447            the constant starting from `best_start', and also starting from
2448            zero (i.e. with bit 31 first to be output).  If `best_start' doesn't
2449            yield a shorter sequence, we may as well use zero.  */
2450         if (best_start != 0
2451             && ((((unsigned HOST_WIDE_INT) 1) << best_start) < remainder)
2452             && (count_insns_for_constant (remainder, 0) <=
2453                 count_insns_for_constant (remainder, best_start)))
2454           best_start = 0;
2455       }
2456
2457     /* Now start emitting the insns.  */
2458     i = best_start;
2459     do
2460       {
2461         int end;
2462
2463         if (i <= 0)
2464           i += 32;
2465         if (remainder & (3 << (i - 2)))
2466           {
2467             end = i - 8;
2468             if (end < 0)
2469               end += 32;
2470             temp1 = remainder & ((0x0ff << end)
2471                                  | ((i < end) ? (0xff >> (32 - end)) : 0));
2472             remainder &= ~temp1;
2473
2474             if (generate)
2475               {
2476                 rtx new_src, temp1_rtx;
2477
2478                 if (code == SET || code == MINUS)
2479                   {
2480                     new_src = (subtargets ? gen_reg_rtx (mode) : target);
2481                     if (can_invert && code != MINUS)
2482                       temp1 = ~temp1;
2483                   }
2484                 else
2485                   {
2486                     if (remainder && subtargets)
2487                       new_src = gen_reg_rtx (mode);
2488                     else
2489                       new_src = target;
2490                     if (can_invert)
2491                       temp1 = ~temp1;
2492                     else if (can_negate)
2493                       temp1 = -temp1;
2494                   }
2495
2496                 temp1 = trunc_int_for_mode (temp1, mode);
2497                 temp1_rtx = GEN_INT (temp1);
2498
2499                 if (code == SET)
2500                   ;
2501                 else if (code == MINUS)
2502                   temp1_rtx = gen_rtx_MINUS (mode, temp1_rtx, source);
2503                 else
2504                   temp1_rtx = gen_rtx_fmt_ee (code, mode, source, temp1_rtx);
2505
2506                 emit_constant_insn (cond,
2507                                     gen_rtx_SET (VOIDmode, new_src,
2508                                                  temp1_rtx));
2509                 source = new_src;
2510               }
2511
2512             if (code == SET)
2513               {
2514                 can_invert = 0;
2515                 code = PLUS;
2516               }
2517             else if (code == MINUS)
2518               code = PLUS;
2519
2520             insns++;
2521             if (TARGET_ARM)
2522               i -= 6;
2523             else
2524               i -= 7;
2525           }
2526         /* Arm allows rotates by a multiple of two. Thumb-2 allows arbitrary
2527            shifts.  */
2528         if (TARGET_ARM)
2529           i -= 2;
2530         else
2531           i--;
2532       }
2533     while (remainder);
2534   }
2535
2536   return insns;
2537 }
2538
2539 /* Canonicalize a comparison so that we are more likely to recognize it.
2540    This can be done for a few constant compares, where we can make the
2541    immediate value easier to load.  */
2542
2543 enum rtx_code
2544 arm_canonicalize_comparison (enum rtx_code code, enum machine_mode mode,
2545                              rtx * op1)
2546 {
2547   unsigned HOST_WIDE_INT i = INTVAL (*op1);
2548   unsigned HOST_WIDE_INT maxval;
2549   maxval = (((unsigned HOST_WIDE_INT) 1) << (GET_MODE_BITSIZE(mode) - 1)) - 1;
2550
2551   switch (code)
2552     {
2553     case EQ:
2554     case NE:
2555       return code;
2556
2557     case GT:
2558     case LE:
2559       if (i != maxval
2560           && (const_ok_for_arm (i + 1) || const_ok_for_arm (-(i + 1))))
2561         {
2562           *op1 = GEN_INT (i + 1);
2563           return code == GT ? GE : LT;
2564         }
2565       break;
2566
2567     case GE:
2568     case LT:
2569       if (i != ~maxval
2570           && (const_ok_for_arm (i - 1) || const_ok_for_arm (-(i - 1))))
2571         {
2572           *op1 = GEN_INT (i - 1);
2573           return code == GE ? GT : LE;
2574         }
2575       break;
2576
2577     case GTU:
2578     case LEU:
2579       if (i != ~((unsigned HOST_WIDE_INT) 0)
2580           && (const_ok_for_arm (i + 1) || const_ok_for_arm (-(i + 1))))
2581         {
2582           *op1 = GEN_INT (i + 1);
2583           return code == GTU ? GEU : LTU;
2584         }
2585       break;
2586
2587     case GEU:
2588     case LTU:
2589       if (i != 0
2590           && (const_ok_for_arm (i - 1) || const_ok_for_arm (-(i - 1))))
2591         {
2592           *op1 = GEN_INT (i - 1);
2593           return code == GEU ? GTU : LEU;
2594         }
2595       break;
2596
2597     default:
2598       gcc_unreachable ();
2599     }
2600
2601   return code;
2602 }
2603
2604
2605 /* Define how to find the value returned by a function.  */
2606
2607 rtx
2608 arm_function_value(tree type, tree func ATTRIBUTE_UNUSED)
2609 {
2610   enum machine_mode mode;
2611   int unsignedp ATTRIBUTE_UNUSED;
2612   rtx r ATTRIBUTE_UNUSED;
2613
2614   mode = TYPE_MODE (type);
2615   /* Promote integer types.  */
2616   if (INTEGRAL_TYPE_P (type))
2617     PROMOTE_FUNCTION_MODE (mode, unsignedp, type);
2618
2619   /* Promotes small structs returned in a register to full-word size
2620      for big-endian AAPCS.  */
2621   if (arm_return_in_msb (type))
2622     {
2623       HOST_WIDE_INT size = int_size_in_bytes (type);
2624       if (size % UNITS_PER_WORD != 0)
2625         {
2626           size += UNITS_PER_WORD - size % UNITS_PER_WORD;
2627           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2628         }
2629     }
2630
2631   return LIBCALL_VALUE(mode);
2632 }
2633
2634 /* Determine the amount of memory needed to store the possible return
2635    registers of an untyped call.  */
2636 int
2637 arm_apply_result_size (void)
2638 {
2639   int size = 16;
2640
2641   if (TARGET_ARM)
2642     {
2643       if (TARGET_HARD_FLOAT_ABI)
2644         {
2645           if (TARGET_FPA)
2646             size += 12;
2647           if (TARGET_MAVERICK)
2648             size += 8;
2649         }
2650       if (TARGET_IWMMXT_ABI)
2651         size += 8;
2652     }
2653
2654   return size;
2655 }
2656
2657 /* Decide whether a type should be returned in memory (true)
2658    or in a register (false).  This is called by the macro
2659    RETURN_IN_MEMORY.  */
2660 int
2661 arm_return_in_memory (tree type)
2662 {
2663   HOST_WIDE_INT size;
2664
2665   if (!AGGREGATE_TYPE_P (type) &&
2666       (TREE_CODE (type) != VECTOR_TYPE) &&
2667       !(TARGET_AAPCS_BASED && TREE_CODE (type) == COMPLEX_TYPE))
2668     /* All simple types are returned in registers.
2669        For AAPCS, complex types are treated the same as aggregates.  */
2670     return 0;
2671
2672   size = int_size_in_bytes (type);
2673
2674   if (arm_abi != ARM_ABI_APCS)
2675     {
2676       /* ATPCS and later return aggregate types in memory only if they are
2677          larger than a word (or are variable size).  */
2678       return (size < 0 || size > UNITS_PER_WORD);
2679     }
2680
2681   /* To maximize backwards compatibility with previous versions of gcc,
2682      return vectors up to 4 words in registers.  */
2683   if (TREE_CODE (type) == VECTOR_TYPE)
2684     return (size < 0 || size > (4 * UNITS_PER_WORD));
2685
2686   /* For the arm-wince targets we choose to be compatible with Microsoft's
2687      ARM and Thumb compilers, which always return aggregates in memory.  */
2688 #ifndef ARM_WINCE
2689   /* All structures/unions bigger than one word are returned in memory.
2690      Also catch the case where int_size_in_bytes returns -1.  In this case
2691      the aggregate is either huge or of variable size, and in either case
2692      we will want to return it via memory and not in a register.  */
2693   if (size < 0 || size > UNITS_PER_WORD)
2694     return 1;
2695
2696   if (TREE_CODE (type) == RECORD_TYPE)
2697     {
2698       tree field;
2699
2700       /* For a struct the APCS says that we only return in a register
2701          if the type is 'integer like' and every addressable element
2702          has an offset of zero.  For practical purposes this means
2703          that the structure can have at most one non bit-field element
2704          and that this element must be the first one in the structure.  */
2705
2706       /* Find the first field, ignoring non FIELD_DECL things which will
2707          have been created by C++.  */
2708       for (field = TYPE_FIELDS (type);
2709            field && TREE_CODE (field) != FIELD_DECL;
2710            field = TREE_CHAIN (field))
2711         continue;
2712
2713       if (field == NULL)
2714         return 0; /* An empty structure.  Allowed by an extension to ANSI C.  */
2715
2716       /* Check that the first field is valid for returning in a register.  */
2717
2718       /* ... Floats are not allowed */
2719       if (FLOAT_TYPE_P (TREE_TYPE (field)))
2720         return 1;
2721
2722       /* ... Aggregates that are not themselves valid for returning in
2723          a register are not allowed.  */
2724       if (RETURN_IN_MEMORY (TREE_TYPE (field)))
2725         return 1;
2726
2727       /* Now check the remaining fields, if any.  Only bitfields are allowed,
2728          since they are not addressable.  */
2729       for (field = TREE_CHAIN (field);
2730            field;
2731            field = TREE_CHAIN (field))
2732         {
2733           if (TREE_CODE (field) != FIELD_DECL)
2734             continue;
2735
2736           if (!DECL_BIT_FIELD_TYPE (field))
2737             return 1;
2738         }
2739
2740       return 0;
2741     }
2742
2743   if (TREE_CODE (type) == UNION_TYPE)
2744     {
2745       tree field;
2746
2747       /* Unions can be returned in registers if every element is
2748          integral, or can be returned in an integer register.  */
2749       for (field = TYPE_FIELDS (type);
2750            field;
2751            field = TREE_CHAIN (field))
2752         {
2753           if (TREE_CODE (field) != FIELD_DECL)
2754             continue;
2755
2756           if (FLOAT_TYPE_P (TREE_TYPE (field)))
2757             return 1;
2758
2759           if (RETURN_IN_MEMORY (TREE_TYPE (field)))
2760             return 1;
2761         }
2762
2763       return 0;
2764     }
2765 #endif /* not ARM_WINCE */
2766
2767   /* Return all other types in memory.  */
2768   return 1;
2769 }
2770
2771 /* Indicate whether or not words of a double are in big-endian order.  */
2772
2773 int
2774 arm_float_words_big_endian (void)
2775 {
2776   if (TARGET_MAVERICK)
2777     return 0;
2778
2779   /* For FPA, float words are always big-endian.  For VFP, floats words
2780      follow the memory system mode.  */
2781
2782   if (TARGET_FPA)
2783     {
2784       return 1;
2785     }
2786
2787   if (TARGET_VFP)
2788     return (TARGET_BIG_END ? 1 : 0);
2789
2790   return 1;
2791 }
2792
2793 /* Initialize a variable CUM of type CUMULATIVE_ARGS
2794    for a call to a function whose data type is FNTYPE.
2795    For a library call, FNTYPE is NULL.  */
2796 void
2797 arm_init_cumulative_args (CUMULATIVE_ARGS *pcum, tree fntype,
2798                           rtx libname  ATTRIBUTE_UNUSED,
2799                           tree fndecl ATTRIBUTE_UNUSED)
2800 {
2801   /* On the ARM, the offset starts at 0.  */
2802   pcum->nregs = 0;
2803   pcum->iwmmxt_nregs = 0;
2804   pcum->can_split = true;
2805
2806   /* Varargs vectors are treated the same as long long.
2807      named_count avoids having to change the way arm handles 'named' */
2808   pcum->named_count = 0;
2809   pcum->nargs = 0;
2810
2811   if (TARGET_REALLY_IWMMXT && fntype)
2812     {
2813       tree fn_arg;
2814
2815       for (fn_arg = TYPE_ARG_TYPES (fntype);
2816            fn_arg;
2817            fn_arg = TREE_CHAIN (fn_arg))
2818         pcum->named_count += 1;
2819
2820       if (! pcum->named_count)
2821         pcum->named_count = INT_MAX;
2822     }
2823 }
2824
2825
2826 /* Return true if mode/type need doubleword alignment.  */
2827 bool
2828 arm_needs_doubleword_align (enum machine_mode mode, tree type)
2829 {
2830   return (GET_MODE_ALIGNMENT (mode) > PARM_BOUNDARY
2831           || (type && TYPE_ALIGN (type) > PARM_BOUNDARY));
2832 }
2833
2834
2835 /* Determine where to put an argument to a function.
2836    Value is zero to push the argument on the stack,
2837    or a hard register in which to store the argument.
2838
2839    MODE is the argument's machine mode.
2840    TYPE is the data type of the argument (as a tree).
2841     This is null for libcalls where that information may
2842     not be available.
2843    CUM is a variable of type CUMULATIVE_ARGS which gives info about
2844     the preceding args and about the function being called.
2845    NAMED is nonzero if this argument is a named parameter
2846     (otherwise it is an extra parameter matching an ellipsis).  */
2847
2848 rtx
2849 arm_function_arg (CUMULATIVE_ARGS *pcum, enum machine_mode mode,
2850                   tree type, int named)
2851 {
2852   int nregs;
2853
2854   /* Varargs vectors are treated the same as long long.
2855      named_count avoids having to change the way arm handles 'named' */
2856   if (TARGET_IWMMXT_ABI
2857       && arm_vector_mode_supported_p (mode)
2858       && pcum->named_count > pcum->nargs + 1)
2859     {
2860       if (pcum->iwmmxt_nregs <= 9)
2861         return gen_rtx_REG (mode, pcum->iwmmxt_nregs + FIRST_IWMMXT_REGNUM);
2862       else
2863         {
2864           pcum->can_split = false;
2865           return NULL_RTX;
2866         }
2867     }
2868
2869   /* Put doubleword aligned quantities in even register pairs.  */
2870   if (pcum->nregs & 1
2871       && ARM_DOUBLEWORD_ALIGN
2872       && arm_needs_doubleword_align (mode, type))
2873     pcum->nregs++;
2874
2875   if (mode == VOIDmode)
2876     /* Pick an arbitrary value for operand 2 of the call insn.  */
2877     return const0_rtx;
2878
2879   /* Only allow splitting an arg between regs and memory if all preceding
2880      args were allocated to regs.  For args passed by reference we only count
2881      the reference pointer.  */
2882   if (pcum->can_split)
2883     nregs = 1;
2884   else
2885     nregs = ARM_NUM_REGS2 (mode, type);
2886
2887   if (!named || pcum->nregs + nregs > NUM_ARG_REGS)
2888     return NULL_RTX;
2889
2890   return gen_rtx_REG (mode, pcum->nregs);
2891 }
2892
2893 static int
2894 arm_arg_partial_bytes (CUMULATIVE_ARGS *pcum, enum machine_mode mode,
2895                        tree type, bool named ATTRIBUTE_UNUSED)
2896 {
2897   int nregs = pcum->nregs;
2898
2899   if (arm_vector_mode_supported_p (mode))
2900     return 0;
2901
2902   if (NUM_ARG_REGS > nregs
2903       && (NUM_ARG_REGS < nregs + ARM_NUM_REGS2 (mode, type))
2904       && pcum->can_split)
2905     return (NUM_ARG_REGS - nregs) * UNITS_PER_WORD;
2906
2907   return 0;
2908 }
2909
2910 /* Variable sized types are passed by reference.  This is a GCC
2911    extension to the ARM ABI.  */
2912
2913 static bool
2914 arm_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
2915                        enum machine_mode mode ATTRIBUTE_UNUSED,
2916                        tree type, bool named ATTRIBUTE_UNUSED)
2917 {
2918   return type && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST;
2919 }
2920 \f
2921 /* Encode the current state of the #pragma [no_]long_calls.  */
2922 typedef enum
2923 {
2924   OFF,          /* No #pragma [no_]long_calls is in effect.  */
2925   LONG,         /* #pragma long_calls is in effect.  */
2926   SHORT         /* #pragma no_long_calls is in effect.  */
2927 } arm_pragma_enum;
2928
2929 static arm_pragma_enum arm_pragma_long_calls = OFF;
2930
2931 void
2932 arm_pr_long_calls (struct cpp_reader * pfile ATTRIBUTE_UNUSED)
2933 {
2934   arm_pragma_long_calls = LONG;
2935 }
2936
2937 void
2938 arm_pr_no_long_calls (struct cpp_reader * pfile ATTRIBUTE_UNUSED)
2939 {
2940   arm_pragma_long_calls = SHORT;
2941 }
2942
2943 void
2944 arm_pr_long_calls_off (struct cpp_reader * pfile ATTRIBUTE_UNUSED)
2945 {
2946   arm_pragma_long_calls = OFF;
2947 }
2948 \f
2949 /* Table of machine attributes.  */
2950 const struct attribute_spec arm_attribute_table[] =
2951 {
2952   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
2953   /* Function calls made to this symbol must be done indirectly, because
2954      it may lie outside of the 26 bit addressing range of a normal function
2955      call.  */
2956   { "long_call",    0, 0, false, true,  true,  NULL },
2957   /* Whereas these functions are always known to reside within the 26 bit
2958      addressing range.  */
2959   { "short_call",   0, 0, false, true,  true,  NULL },
2960   /* Interrupt Service Routines have special prologue and epilogue requirements.  */
2961   { "isr",          0, 1, false, false, false, arm_handle_isr_attribute },
2962   { "interrupt",    0, 1, false, false, false, arm_handle_isr_attribute },
2963   { "naked",        0, 0, true,  false, false, arm_handle_fndecl_attribute },
2964 #ifdef ARM_PE
2965   /* ARM/PE has three new attributes:
2966      interfacearm - ?
2967      dllexport - for exporting a function/variable that will live in a dll
2968      dllimport - for importing a function/variable from a dll
2969
2970      Microsoft allows multiple declspecs in one __declspec, separating
2971      them with spaces.  We do NOT support this.  Instead, use __declspec
2972      multiple times.
2973   */
2974   { "dllimport",    0, 0, true,  false, false, NULL },
2975   { "dllexport",    0, 0, true,  false, false, NULL },
2976   { "interfacearm", 0, 0, true,  false, false, arm_handle_fndecl_attribute },
2977 #elif TARGET_DLLIMPORT_DECL_ATTRIBUTES
2978   { "dllimport",    0, 0, false, false, false, handle_dll_attribute },
2979   { "dllexport",    0, 0, false, false, false, handle_dll_attribute },
2980   { "notshared",    0, 0, false, true, false, arm_handle_notshared_attribute },
2981 #endif
2982   { NULL,           0, 0, false, false, false, NULL }
2983 };
2984
2985 /* Handle an attribute requiring a FUNCTION_DECL;
2986    arguments as in struct attribute_spec.handler.  */
2987 static tree
2988 arm_handle_fndecl_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
2989                              int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
2990 {
2991   if (TREE_CODE (*node) != FUNCTION_DECL)
2992     {
2993       warning (OPT_Wattributes, "%qs attribute only applies to functions",
2994                IDENTIFIER_POINTER (name));
2995       *no_add_attrs = true;
2996     }
2997
2998   return NULL_TREE;
2999 }
3000
3001 /* Handle an "interrupt" or "isr" attribute;
3002    arguments as in struct attribute_spec.handler.  */
3003 static tree
3004 arm_handle_isr_attribute (tree *node, tree name, tree args, int flags,
3005                           bool *no_add_attrs)
3006 {
3007   if (DECL_P (*node))
3008     {
3009       if (TREE_CODE (*node) != FUNCTION_DECL)
3010         {
3011           warning (OPT_Wattributes, "%qs attribute only applies to functions",
3012                    IDENTIFIER_POINTER (name));
3013           *no_add_attrs = true;
3014         }
3015       /* FIXME: the argument if any is checked for type attributes;
3016          should it be checked for decl ones?  */
3017     }
3018   else
3019     {
3020       if (TREE_CODE (*node) == FUNCTION_TYPE
3021           || TREE_CODE (*node) == METHOD_TYPE)
3022         {
3023           if (arm_isr_value (args) == ARM_FT_UNKNOWN)
3024             {
3025               warning (OPT_Wattributes, "%qs attribute ignored",
3026                        IDENTIFIER_POINTER (name));
3027               *no_add_attrs = true;
3028             }
3029         }
3030       else if (TREE_CODE (*node) == POINTER_TYPE
3031                && (TREE_CODE (TREE_TYPE (*node)) == FUNCTION_TYPE
3032                    || TREE_CODE (TREE_TYPE (*node)) == METHOD_TYPE)
3033                && arm_isr_value (args) != ARM_FT_UNKNOWN)
3034         {
3035           *node = build_variant_type_copy (*node);
3036           TREE_TYPE (*node) = build_type_attribute_variant
3037             (TREE_TYPE (*node),
3038              tree_cons (name, args, TYPE_ATTRIBUTES (TREE_TYPE (*node))));
3039           *no_add_attrs = true;
3040         }
3041       else
3042         {
3043           /* Possibly pass this attribute on from the type to a decl.  */
3044           if (flags & ((int) ATTR_FLAG_DECL_NEXT
3045                        | (int) ATTR_FLAG_FUNCTION_NEXT
3046                        | (int) ATTR_FLAG_ARRAY_NEXT))
3047             {
3048               *no_add_attrs = true;
3049               return tree_cons (name, args, NULL_TREE);
3050             }
3051           else
3052             {
3053               warning (OPT_Wattributes, "%qs attribute ignored",
3054                        IDENTIFIER_POINTER (name));
3055             }
3056         }
3057     }
3058
3059   return NULL_TREE;
3060 }
3061
3062 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
3063 /* Handle the "notshared" attribute.  This attribute is another way of
3064    requesting hidden visibility.  ARM's compiler supports
3065    "__declspec(notshared)"; we support the same thing via an
3066    attribute.  */
3067
3068 static tree
3069 arm_handle_notshared_attribute (tree *node,
3070                                 tree name ATTRIBUTE_UNUSED,
3071                                 tree args ATTRIBUTE_UNUSED,
3072                                 int flags ATTRIBUTE_UNUSED,
3073                                 bool *no_add_attrs)
3074 {
3075   tree decl = TYPE_NAME (*node);
3076
3077   if (decl)
3078     {
3079       DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
3080       DECL_VISIBILITY_SPECIFIED (decl) = 1;
3081       *no_add_attrs = false;
3082     }
3083   return NULL_TREE;
3084 }
3085 #endif
3086
3087 /* Return 0 if the attributes for two types are incompatible, 1 if they
3088    are compatible, and 2 if they are nearly compatible (which causes a
3089    warning to be generated).  */
3090 static int
3091 arm_comp_type_attributes (tree type1, tree type2)
3092 {
3093   int l1, l2, s1, s2;
3094
3095   /* Check for mismatch of non-default calling convention.  */
3096   if (TREE_CODE (type1) != FUNCTION_TYPE)
3097     return 1;
3098
3099   /* Check for mismatched call attributes.  */
3100   l1 = lookup_attribute ("long_call", TYPE_ATTRIBUTES (type1)) != NULL;
3101   l2 = lookup_attribute ("long_call", TYPE_ATTRIBUTES (type2)) != NULL;
3102   s1 = lookup_attribute ("short_call", TYPE_ATTRIBUTES (type1)) != NULL;
3103   s2 = lookup_attribute ("short_call", TYPE_ATTRIBUTES (type2)) != NULL;
3104
3105   /* Only bother to check if an attribute is defined.  */
3106   if (l1 | l2 | s1 | s2)
3107     {
3108       /* If one type has an attribute, the other must have the same attribute.  */
3109       if ((l1 != l2) || (s1 != s2))
3110         return 0;
3111
3112       /* Disallow mixed attributes.  */
3113       if ((l1 & s2) || (l2 & s1))
3114         return 0;
3115     }
3116
3117   /* Check for mismatched ISR attribute.  */
3118   l1 = lookup_attribute ("isr", TYPE_ATTRIBUTES (type1)) != NULL;
3119   if (! l1)
3120     l1 = lookup_attribute ("interrupt", TYPE_ATTRIBUTES (type1)) != NULL;
3121   l2 = lookup_attribute ("isr", TYPE_ATTRIBUTES (type2)) != NULL;
3122   if (! l2)
3123     l1 = lookup_attribute ("interrupt", TYPE_ATTRIBUTES (type2)) != NULL;
3124   if (l1 != l2)
3125     return 0;
3126
3127   return 1;
3128 }
3129
3130 /*  Assigns default attributes to newly defined type.  This is used to
3131     set short_call/long_call attributes for function types of
3132     functions defined inside corresponding #pragma scopes.  */
3133 static void
3134 arm_set_default_type_attributes (tree type)
3135 {
3136   /* Add __attribute__ ((long_call)) to all functions, when
3137      inside #pragma long_calls or __attribute__ ((short_call)),
3138      when inside #pragma no_long_calls.  */
3139   if (TREE_CODE (type) == FUNCTION_TYPE || TREE_CODE (type) == METHOD_TYPE)
3140     {
3141       tree type_attr_list, attr_name;
3142       type_attr_list = TYPE_ATTRIBUTES (type);
3143
3144       if (arm_pragma_long_calls == LONG)
3145         attr_name = get_identifier ("long_call");
3146       else if (arm_pragma_long_calls == SHORT)
3147         attr_name = get_identifier ("short_call");
3148       else
3149         return;
3150
3151       type_attr_list = tree_cons (attr_name, NULL_TREE, type_attr_list);
3152       TYPE_ATTRIBUTES (type) = type_attr_list;
3153     }
3154 }
3155 \f
3156 /* Return true if DECL is known to be linked into section SECTION.  */
3157
3158 static bool
3159 arm_function_in_section_p (tree decl, section *section)
3160 {
3161   /* We can only be certain about functions defined in the same
3162      compilation unit.  */
3163   if (!TREE_STATIC (decl))
3164     return false;
3165
3166   /* Make sure that SYMBOL always binds to the definition in this
3167      compilation unit.  */
3168   if (!targetm.binds_local_p (decl))
3169     return false;
3170
3171   /* If DECL_SECTION_NAME is set, assume it is trustworthy.  */
3172   if (!DECL_SECTION_NAME (decl))
3173     {
3174       /* Only cater for unit-at-a-time mode, where we know that the user
3175          cannot later specify a section for DECL.  */
3176       if (!flag_unit_at_a_time)
3177         return false;
3178
3179       /* Make sure that we will not create a unique section for DECL.  */
3180       if (flag_function_sections || DECL_ONE_ONLY (decl))
3181         return false;
3182     }
3183
3184   return function_section (decl) == section;
3185 }
3186
3187 /* Return nonzero if a 32-bit "long_call" should be generated for
3188    a call from the current function to DECL.  We generate a long_call
3189    if the function:
3190
3191         a.  has an __attribute__((long call))
3192      or b.  is within the scope of a #pragma long_calls
3193      or c.  the -mlong-calls command line switch has been specified
3194
3195    However we do not generate a long call if the function:
3196
3197         d.  has an __attribute__ ((short_call))
3198      or e.  is inside the scope of a #pragma no_long_calls
3199      or f.  is defined in the same section as the current function.  */
3200
3201 bool
3202 arm_is_long_call_p (tree decl)
3203 {
3204   tree attrs;
3205
3206   if (!decl)
3207     return TARGET_LONG_CALLS;
3208
3209   attrs = TYPE_ATTRIBUTES (TREE_TYPE (decl));
3210   if (lookup_attribute ("short_call", attrs))
3211     return false;
3212
3213   /* For "f", be conservative, and only cater for cases in which the
3214      whole of the current function is placed in the same section.  */
3215   if (!flag_reorder_blocks_and_partition
3216       && arm_function_in_section_p (decl, current_function_section ()))
3217     return false;
3218
3219   if (lookup_attribute ("long_call", attrs))
3220     return true;
3221
3222   return TARGET_LONG_CALLS;
3223 }
3224
3225 /* Return nonzero if it is ok to make a tail-call to DECL.  */
3226 static bool
3227 arm_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
3228 {
3229   unsigned long func_type;
3230
3231   if (cfun->machine->sibcall_blocked)
3232     return false;
3233
3234   /* Never tailcall something for which we have no decl, or if we
3235      are in Thumb mode.  */
3236   if (decl == NULL || TARGET_THUMB)
3237     return false;
3238
3239   /* The PIC register is live on entry to VxWorks PLT entries, so we
3240      must make the call before restoring the PIC register.  */
3241   if (TARGET_VXWORKS_RTP && flag_pic && !targetm.binds_local_p (decl))
3242     return false;
3243
3244   /* Cannot tail-call to long calls, since these are out of range of
3245      a branch instruction.  */
3246   if (arm_is_long_call_p (decl))
3247     return false;
3248
3249   /* If we are interworking and the function is not declared static
3250      then we can't tail-call it unless we know that it exists in this
3251      compilation unit (since it might be a Thumb routine).  */
3252   if (TARGET_INTERWORK && TREE_PUBLIC (decl) && !TREE_ASM_WRITTEN (decl))
3253     return false;
3254
3255   func_type = arm_current_func_type ();
3256   /* Never tailcall from an ISR routine - it needs a special exit sequence.  */
3257   if (IS_INTERRUPT (func_type))
3258     return false;
3259
3260   /* Never tailcall if function may be called with a misaligned SP.  */
3261   if (IS_STACKALIGN (func_type))
3262     return false;
3263
3264   /* Everything else is ok.  */
3265   return true;
3266 }
3267
3268 \f
3269 /* Addressing mode support functions.  */
3270
3271 /* Return nonzero if X is a legitimate immediate operand when compiling
3272    for PIC.  We know that X satisfies CONSTANT_P and flag_pic is true.  */
3273 int
3274 legitimate_pic_operand_p (rtx x)
3275 {
3276   if (GET_CODE (x) == SYMBOL_REF
3277       || (GET_CODE (x) == CONST
3278           && GET_CODE (XEXP (x, 0)) == PLUS
3279           && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF))
3280     return 0;
3281
3282   return 1;
3283 }
3284
3285 /* Record that the current function needs a PIC register.  Initialize
3286    cfun->machine->pic_reg if we have not already done so.  */
3287
3288 static void
3289 require_pic_register (void)
3290 {
3291   /* A lot of the logic here is made obscure by the fact that this
3292      routine gets called as part of the rtx cost estimation process.
3293      We don't want those calls to affect any assumptions about the real
3294      function; and further, we can't call entry_of_function() until we
3295      start the real expansion process.  */
3296   if (!current_function_uses_pic_offset_table)
3297     {
3298       gcc_assert (!no_new_pseudos);
3299       if (arm_pic_register != INVALID_REGNUM)
3300         {
3301           cfun->machine->pic_reg = gen_rtx_REG (Pmode, arm_pic_register);
3302
3303           /* Play games to avoid marking the function as needing pic
3304              if we are being called as part of the cost-estimation
3305              process.  */
3306           if (current_ir_type () != IR_GIMPLE)
3307             current_function_uses_pic_offset_table = 1;
3308         }
3309       else
3310         {
3311           rtx seq;
3312
3313           cfun->machine->pic_reg = gen_reg_rtx (Pmode);
3314
3315           /* Play games to avoid marking the function as needing pic
3316              if we are being called as part of the cost-estimation
3317              process.  */
3318           if (current_ir_type () != IR_GIMPLE)
3319             {
3320               current_function_uses_pic_offset_table = 1;
3321               start_sequence ();
3322
3323               arm_load_pic_register (0UL);
3324
3325               seq = get_insns ();
3326               end_sequence ();
3327               emit_insn_after (seq, entry_of_function ());
3328             }
3329         }
3330     }
3331 }
3332
3333 rtx
3334 legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
3335 {
3336   if (GET_CODE (orig) == SYMBOL_REF
3337       || GET_CODE (orig) == LABEL_REF)
3338     {
3339 #ifndef AOF_ASSEMBLER
3340       rtx pic_ref, address;
3341 #endif
3342       rtx insn;
3343       int subregs = 0;
3344
3345       /* If this function doesn't have a pic register, create one now.  */
3346       require_pic_register ();
3347
3348       if (reg == 0)
3349         {
3350           gcc_assert (!no_new_pseudos);
3351           reg = gen_reg_rtx (Pmode);
3352
3353           subregs = 1;
3354         }
3355
3356 #ifdef AOF_ASSEMBLER
3357       /* The AOF assembler can generate relocations for these directly, and
3358          understands that the PIC register has to be added into the offset.  */
3359       insn = emit_insn (gen_pic_load_addr_based (reg, orig));
3360 #else
3361       if (subregs)
3362         address = gen_reg_rtx (Pmode);
3363       else
3364         address = reg;
3365
3366       if (TARGET_ARM)
3367         emit_insn (gen_pic_load_addr_arm (address, orig));
3368       else if (TARGET_THUMB2)
3369         emit_insn (gen_pic_load_addr_thumb2 (address, orig));
3370       else /* TARGET_THUMB1 */
3371         emit_insn (gen_pic_load_addr_thumb1 (address, orig));
3372
3373       /* VxWorks does not impose a fixed gap between segments; the run-time
3374          gap can be different from the object-file gap.  We therefore can't
3375          use GOTOFF unless we are absolutely sure that the symbol is in the
3376          same segment as the GOT.  Unfortunately, the flexibility of linker
3377          scripts means that we can't be sure of that in general, so assume
3378          that GOTOFF is never valid on VxWorks.  */
3379       if ((GET_CODE (orig) == LABEL_REF
3380            || (GET_CODE (orig) == SYMBOL_REF &&
3381                SYMBOL_REF_LOCAL_P (orig)))
3382           && NEED_GOT_RELOC
3383           && !TARGET_VXWORKS_RTP)
3384         pic_ref = gen_rtx_PLUS (Pmode, cfun->machine->pic_reg, address);
3385       else
3386         {
3387           pic_ref = gen_const_mem (Pmode,
3388                                    gen_rtx_PLUS (Pmode, cfun->machine->pic_reg,
3389                                                  address));
3390         }
3391
3392       insn = emit_move_insn (reg, pic_ref);
3393 #endif
3394       /* Put a REG_EQUAL note on this insn, so that it can be optimized
3395          by loop.  */
3396       set_unique_reg_note (insn, REG_EQUAL, orig);
3397
3398       return reg;
3399     }
3400   else if (GET_CODE (orig) == CONST)
3401     {
3402       rtx base, offset;
3403
3404       if (GET_CODE (XEXP (orig, 0)) == PLUS
3405           && XEXP (XEXP (orig, 0), 0) == cfun->machine->pic_reg)
3406         return orig;
3407
3408       if (GET_CODE (XEXP (orig, 0)) == UNSPEC
3409           && XINT (XEXP (orig, 0), 1) == UNSPEC_TLS)
3410         return orig;
3411
3412       if (reg == 0)
3413         {
3414           gcc_assert (!no_new_pseudos);
3415           reg = gen_reg_rtx (Pmode);
3416         }
3417
3418       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
3419
3420       base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
3421       offset = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
3422                                        base == reg ? 0 : reg);
3423
3424       if (GET_CODE (offset) == CONST_INT)
3425         {
3426           /* The base register doesn't really matter, we only want to
3427              test the index for the appropriate mode.  */
3428           if (!arm_legitimate_index_p (mode, offset, SET, 0))
3429             {
3430               gcc_assert (!no_new_pseudos);
3431               offset = force_reg (Pmode, offset);
3432             }
3433
3434           if (GET_CODE (offset) == CONST_INT)
3435             return plus_constant (base, INTVAL (offset));
3436         }
3437
3438       if (GET_MODE_SIZE (mode) > 4
3439           && (GET_MODE_CLASS (mode) == MODE_INT
3440               || TARGET_SOFT_FLOAT))
3441         {
3442           emit_insn (gen_addsi3 (reg, base, offset));
3443           return reg;
3444         }
3445
3446       return gen_rtx_PLUS (Pmode, base, offset);
3447     }
3448
3449   return orig;
3450 }
3451
3452
3453 /* Find a spare register to use during the prolog of a function.  */
3454
3455 static int
3456 thumb_find_work_register (unsigned long pushed_regs_mask)
3457 {
3458   int reg;
3459
3460   /* Check the argument registers first as these are call-used.  The
3461      register allocation order means that sometimes r3 might be used
3462      but earlier argument registers might not, so check them all.  */
3463   for (reg = LAST_ARG_REGNUM; reg >= 0; reg --)
3464     if (!df_regs_ever_live_p (reg))
3465       return reg;
3466
3467   /* Before going on to check the call-saved registers we can try a couple
3468      more ways of deducing that r3 is available.  The first is when we are
3469      pushing anonymous arguments onto the stack and we have less than 4
3470      registers worth of fixed arguments(*).  In this case r3 will be part of
3471      the variable argument list and so we can be sure that it will be
3472      pushed right at the start of the function.  Hence it will be available
3473      for the rest of the prologue.
3474      (*): ie current_function_pretend_args_size is greater than 0.  */
3475   if (cfun->machine->uses_anonymous_args
3476       && current_function_pretend_args_size > 0)
3477     return LAST_ARG_REGNUM;
3478
3479   /* The other case is when we have fixed arguments but less than 4 registers
3480      worth.  In this case r3 might be used in the body of the function, but
3481      it is not being used to convey an argument into the function.  In theory
3482      we could just check current_function_args_size to see how many bytes are
3483      being passed in argument registers, but it seems that it is unreliable.
3484      Sometimes it will have the value 0 when in fact arguments are being
3485      passed.  (See testcase execute/20021111-1.c for an example).  So we also
3486      check the args_info.nregs field as well.  The problem with this field is
3487      that it makes no allowances for arguments that are passed to the
3488      function but which are not used.  Hence we could miss an opportunity
3489      when a function has an unused argument in r3.  But it is better to be
3490      safe than to be sorry.  */
3491   if (! cfun->machine->uses_anonymous_args
3492       && current_function_args_size >= 0
3493       && current_function_args_size <= (LAST_ARG_REGNUM * UNITS_PER_WORD)
3494       && cfun->args_info.nregs < 4)
3495     return LAST_ARG_REGNUM;
3496
3497   /* Otherwise look for a call-saved register that is going to be pushed.  */
3498   for (reg = LAST_LO_REGNUM; reg > LAST_ARG_REGNUM; reg --)
3499     if (pushed_regs_mask & (1 << reg))
3500       return reg;
3501
3502   if (TARGET_THUMB2)
3503     {
3504       /* Thumb-2 can use high regs.  */
3505       for (reg = FIRST_HI_REGNUM; reg < 15; reg ++)
3506         if (pushed_regs_mask & (1 << reg))
3507           return reg;
3508     }
3509   /* Something went wrong - thumb_compute_save_reg_mask()
3510      should have arranged for a suitable register to be pushed.  */
3511   gcc_unreachable ();
3512 }
3513
3514 static GTY(()) int pic_labelno;
3515
3516 /* Generate code to load the PIC register.  In thumb mode SCRATCH is a
3517    low register.  */
3518
3519 void
3520 arm_load_pic_register (unsigned long saved_regs ATTRIBUTE_UNUSED)
3521 {
3522 #ifndef AOF_ASSEMBLER
3523   rtx l1, labelno, pic_tmp, pic_tmp2, pic_rtx, pic_reg;
3524   rtx global_offset_table;
3525
3526   if (current_function_uses_pic_offset_table == 0 || TARGET_SINGLE_PIC_BASE)
3527     return;
3528
3529   gcc_assert (flag_pic);
3530
3531   pic_reg = cfun->machine->pic_reg;
3532   if (TARGET_VXWORKS_RTP)
3533     {
3534       pic_rtx = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_BASE);
3535       pic_rtx = gen_rtx_CONST (Pmode, pic_rtx);
3536       emit_insn (gen_pic_load_addr_arm (pic_reg, pic_rtx));
3537
3538       emit_insn (gen_rtx_SET (Pmode, pic_reg, gen_rtx_MEM (Pmode, pic_reg)));
3539
3540       pic_tmp = gen_rtx_SYMBOL_REF (Pmode, VXWORKS_GOTT_INDEX);
3541       emit_insn (gen_pic_offset_arm (pic_reg, pic_reg, pic_tmp));
3542     }
3543   else
3544     {
3545       /* We use an UNSPEC rather than a LABEL_REF because this label
3546          never appears in the code stream.  */
3547
3548       labelno = GEN_INT (pic_labelno++);
3549       l1 = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, labelno), UNSPEC_PIC_LABEL);
3550       l1 = gen_rtx_CONST (VOIDmode, l1);
3551
3552       global_offset_table
3553         = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
3554       /* On the ARM the PC register contains 'dot + 8' at the time of the
3555          addition, on the Thumb it is 'dot + 4'.  */
3556       pic_tmp = plus_constant (l1, TARGET_ARM ? 8 : 4);
3557       if (GOT_PCREL)
3558         {
3559           pic_tmp2 = gen_rtx_PLUS (Pmode, global_offset_table, pc_rtx);
3560           pic_tmp2 = gen_rtx_CONST (VOIDmode, pic_tmp2);
3561         }
3562       else
3563         pic_tmp2 = gen_rtx_CONST (VOIDmode, global_offset_table);
3564
3565       pic_rtx = gen_rtx_MINUS (Pmode, pic_tmp2, pic_tmp);
3566       pic_rtx = gen_rtx_CONST (Pmode, pic_rtx);
3567
3568       if (TARGET_ARM)
3569         {
3570           emit_insn (gen_pic_load_addr_arm (pic_reg, pic_rtx));
3571           emit_insn (gen_pic_add_dot_plus_eight (pic_reg, pic_reg, labelno));
3572         }
3573       else if (TARGET_THUMB2)
3574         {
3575           /* Thumb-2 only allows very limited access to the PC.  Calculate the
3576              address in a temporary register.  */
3577           if (arm_pic_register != INVALID_REGNUM)
3578             {
3579               pic_tmp = gen_rtx_REG (SImode,
3580                                      thumb_find_work_register (saved_regs));
3581             }
3582           else
3583             {
3584               gcc_assert (!no_new_pseudos);
3585               pic_tmp = gen_reg_rtx (Pmode);
3586             }
3587
3588           emit_insn (gen_pic_load_addr_thumb2 (pic_reg, pic_rtx));
3589           emit_insn (gen_pic_load_dot_plus_four (pic_tmp, labelno));
3590           emit_insn (gen_addsi3 (pic_reg, pic_reg, pic_tmp));
3591         }
3592       else /* TARGET_THUMB1 */
3593         {
3594           if (arm_pic_register != INVALID_REGNUM
3595               && REGNO (pic_reg) > LAST_LO_REGNUM)
3596             {
3597               /* We will have pushed the pic register, so we should always be
3598                  able to find a work register.  */
3599               pic_tmp = gen_rtx_REG (SImode,
3600                                      thumb_find_work_register (saved_regs));
3601               emit_insn (gen_pic_load_addr_thumb1 (pic_tmp, pic_rtx));
3602               emit_insn (gen_movsi (pic_offset_table_rtx, pic_tmp));
3603             }
3604           else
3605             emit_insn (gen_pic_load_addr_thumb1 (pic_reg, pic_rtx));
3606           emit_insn (gen_pic_add_dot_plus_four (pic_reg, pic_reg, labelno));
3607         }
3608     }
3609
3610   /* Need to emit this whether or not we obey regdecls,
3611      since setjmp/longjmp can cause life info to screw up.  */
3612   emit_insn (gen_rtx_USE (VOIDmode, pic_reg));
3613 #endif /* AOF_ASSEMBLER */
3614 }
3615
3616
3617 /* Return nonzero if X is valid as an ARM state addressing register.  */
3618 static int
3619 arm_address_register_rtx_p (rtx x, int strict_p)
3620 {
3621   int regno;
3622
3623   if (GET_CODE (x) != REG)
3624     return 0;
3625
3626   regno = REGNO (x);
3627
3628   if (strict_p)
3629     return ARM_REGNO_OK_FOR_BASE_P (regno);
3630
3631   return (regno <= LAST_ARM_REGNUM
3632           || regno >= FIRST_PSEUDO_REGISTER
3633           || regno == FRAME_POINTER_REGNUM
3634           || regno == ARG_POINTER_REGNUM);
3635 }
3636
3637 /* Return TRUE if this rtx is the difference of a symbol and a label,
3638    and will reduce to a PC-relative relocation in the object file.
3639    Expressions like this can be left alone when generating PIC, rather
3640    than forced through the GOT.  */
3641 static int
3642 pcrel_constant_p (rtx x)
3643 {
3644   if (GET_CODE (x) == MINUS)
3645     return symbol_mentioned_p (XEXP (x, 0)) && label_mentioned_p (XEXP (x, 1));
3646
3647   return FALSE;
3648 }
3649
3650 /* Return nonzero if X is a valid ARM state address operand.  */
3651 int
3652 arm_legitimate_address_p (enum machine_mode mode, rtx x, RTX_CODE outer,
3653                           int strict_p)
3654 {
3655   bool use_ldrd;
3656   enum rtx_code code = GET_CODE (x);
3657
3658   if (arm_address_register_rtx_p (x, strict_p))
3659     return 1;
3660
3661   use_ldrd = (TARGET_LDRD
3662               && (mode == DImode
3663                   || (mode == DFmode && (TARGET_SOFT_FLOAT || TARGET_VFP))));
3664
3665   if (code == POST_INC || code == PRE_DEC
3666       || ((code == PRE_INC || code == POST_DEC)
3667           && (use_ldrd || GET_MODE_SIZE (mode) <= 4)))
3668     return arm_address_register_rtx_p (XEXP (x, 0), strict_p);
3669
3670   else if ((code == POST_MODIFY || code == PRE_MODIFY)
3671            && arm_address_register_rtx_p (XEXP (x, 0), strict_p)
3672            && GET_CODE (XEXP (x, 1)) == PLUS
3673            && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
3674     {
3675       rtx addend = XEXP (XEXP (x, 1), 1);
3676
3677       /* Don't allow ldrd post increment by register because it's hard
3678          to fixup invalid register choices.  */
3679       if (use_ldrd
3680           && GET_CODE (x) == POST_MODIFY
3681           && GET_CODE (addend) == REG)
3682         return 0;
3683
3684       return ((use_ldrd || GET_MODE_SIZE (mode) <= 4)
3685               && arm_legitimate_index_p (mode, addend, outer, strict_p));
3686     }
3687
3688   /* After reload constants split into minipools will have addresses
3689      from a LABEL_REF.  */
3690   else if (reload_completed
3691            && (code == LABEL_REF
3692                || (code == CONST
3693                    && GET_CODE (XEXP (x, 0)) == PLUS
3694                    && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3695                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)))
3696     return 1;
3697
3698   else if (mode == TImode)
3699     return 0;
3700
3701   else if (code == PLUS)
3702     {
3703       rtx xop0 = XEXP (x, 0);
3704       rtx xop1 = XEXP (x, 1);
3705
3706       return ((arm_address_register_rtx_p (xop0, strict_p)
3707                && arm_legitimate_index_p (mode, xop1, outer, strict_p))
3708               || (arm_address_register_rtx_p (xop1, strict_p)
3709                   && arm_legitimate_index_p (mode, xop0, outer, strict_p)));
3710     }
3711
3712 #if 0
3713   /* Reload currently can't handle MINUS, so disable this for now */
3714   else if (GET_CODE (x) == MINUS)
3715     {
3716       rtx xop0 = XEXP (x, 0);
3717       rtx xop1 = XEXP (x, 1);
3718
3719       return (arm_address_register_rtx_p (xop0, strict_p)
3720               && arm_legitimate_index_p (mode, xop1, outer, strict_p));
3721     }
3722 #endif
3723
3724   else if (GET_MODE_CLASS (mode) != MODE_FLOAT
3725            && code == SYMBOL_REF
3726            && CONSTANT_POOL_ADDRESS_P (x)
3727            && ! (flag_pic
3728                  && symbol_mentioned_p (get_pool_constant (x))
3729                  && ! pcrel_constant_p (get_pool_constant (x))))
3730     return 1;
3731
3732   return 0;
3733 }
3734
3735 /* Return nonzero if X is a valid Thumb-2 address operand.  */
3736 int
3737 thumb2_legitimate_address_p (enum machine_mode mode, rtx x, int strict_p)
3738 {
3739   bool use_ldrd;
3740   enum rtx_code code = GET_CODE (x);
3741   
3742   if (arm_address_register_rtx_p (x, strict_p))
3743     return 1;
3744
3745   use_ldrd = (TARGET_LDRD
3746               && (mode == DImode
3747                   || (mode == DFmode && (TARGET_SOFT_FLOAT || TARGET_VFP))));
3748
3749   if (code == POST_INC || code == PRE_DEC
3750       || ((code == PRE_INC || code == POST_DEC)
3751           && (use_ldrd || GET_MODE_SIZE (mode) <= 4)))
3752     return arm_address_register_rtx_p (XEXP (x, 0), strict_p);
3753
3754   else if ((code == POST_MODIFY || code == PRE_MODIFY)
3755            && arm_address_register_rtx_p (XEXP (x, 0), strict_p)
3756            && GET_CODE (XEXP (x, 1)) == PLUS
3757            && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
3758     {
3759       /* Thumb-2 only has autoincrement by constant.  */
3760       rtx addend = XEXP (XEXP (x, 1), 1);
3761       HOST_WIDE_INT offset;
3762
3763       if (GET_CODE (addend) != CONST_INT)
3764         return 0;
3765
3766       offset = INTVAL(addend);
3767       if (GET_MODE_SIZE (mode) <= 4)
3768         return (offset > -256 && offset < 256);
3769       
3770       return (use_ldrd && offset > -1024 && offset < 1024
3771               && (offset & 3) == 0);
3772     }
3773
3774   /* After reload constants split into minipools will have addresses
3775      from a LABEL_REF.  */
3776   else if (reload_completed
3777            && (code == LABEL_REF
3778                || (code == CONST
3779                    && GET_CODE (XEXP (x, 0)) == PLUS
3780                    && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3781                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)))
3782     return 1;
3783
3784   else if (mode == TImode)
3785     return 0;
3786
3787   else if (code == PLUS)
3788     {
3789       rtx xop0 = XEXP (x, 0);
3790       rtx xop1 = XEXP (x, 1);
3791
3792       return ((arm_address_register_rtx_p (xop0, strict_p)
3793                && thumb2_legitimate_index_p (mode, xop1, strict_p))
3794               || (arm_address_register_rtx_p (xop1, strict_p)
3795                   && thumb2_legitimate_index_p (mode, xop0, strict_p)));
3796     }
3797
3798   else if (GET_MODE_CLASS (mode) != MODE_FLOAT
3799            && code == SYMBOL_REF
3800            && CONSTANT_POOL_ADDRESS_P (x)
3801            && ! (flag_pic
3802                  && symbol_mentioned_p (get_pool_constant (x))
3803                  && ! pcrel_constant_p (get_pool_constant (x))))
3804     return 1;
3805
3806   return 0;
3807 }
3808
3809 /* Return nonzero if INDEX is valid for an address index operand in
3810    ARM state.  */
3811 static int
3812 arm_legitimate_index_p (enum machine_mode mode, rtx index, RTX_CODE outer,
3813                         int strict_p)
3814 {
3815   HOST_WIDE_INT range;
3816   enum rtx_code code = GET_CODE (index);
3817
3818   /* Standard coprocessor addressing modes.  */
3819   if (TARGET_HARD_FLOAT
3820       && (TARGET_FPA || TARGET_MAVERICK)
3821       && (GET_MODE_CLASS (mode) == MODE_FLOAT
3822           || (TARGET_MAVERICK && mode == DImode)))
3823     return (code == CONST_INT && INTVAL (index) < 1024
3824             && INTVAL (index) > -1024
3825             && (INTVAL (index) & 3) == 0);
3826
3827   if (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (mode))
3828     return (code == CONST_INT
3829             && INTVAL (index) < 1024
3830             && INTVAL (index) > -1024
3831             && (INTVAL (index) & 3) == 0);
3832
3833   if (arm_address_register_rtx_p (index, strict_p)
3834       && (GET_MODE_SIZE (mode) <= 4))
3835     return 1;
3836
3837   if (mode == DImode || mode == DFmode)
3838     {
3839       if (code == CONST_INT)
3840         {
3841           HOST_WIDE_INT val = INTVAL (index);
3842
3843           if (TARGET_LDRD)
3844             return val > -256 && val < 256;
3845           else
3846             return val > -4096 && val < 4092;
3847         }
3848
3849       return TARGET_LDRD && arm_address_register_rtx_p (index, strict_p);
3850     }
3851
3852   if (GET_MODE_SIZE (mode) <= 4
3853       && ! (arm_arch4
3854             && (mode == HImode
3855                 || (mode == QImode && outer == SIGN_EXTEND))))
3856     {
3857       if (code == MULT)
3858         {
3859           rtx xiop0 = XEXP (index, 0);
3860           rtx xiop1 = XEXP (index, 1);
3861
3862           return ((arm_address_register_rtx_p (xiop0, strict_p)
3863                    && power_of_two_operand (xiop1, SImode))
3864                   || (arm_address_register_rtx_p (xiop1, strict_p)
3865                       && power_of_two_operand (xiop0, SImode)));
3866         }
3867       else if (code == LSHIFTRT || code == ASHIFTRT
3868                || code == ASHIFT || code == ROTATERT)
3869         {
3870           rtx op = XEXP (index, 1);
3871
3872           return (arm_address_register_rtx_p (XEXP (index, 0), strict_p)
3873                   && GET_CODE (op) == CONST_INT
3874                   && INTVAL (op) > 0
3875                   && INTVAL (op) <= 31);
3876         }
3877     }
3878
3879   /* For ARM v4 we may be doing a sign-extend operation during the
3880      load.  */
3881   if (arm_arch4)
3882     {
3883       if (mode == HImode || (outer == SIGN_EXTEND && mode == QImode))
3884         range = 256;
3885       else
3886         range = 4096;
3887     }
3888   else
3889     range = (mode == HImode) ? 4095 : 4096;
3890
3891   return (code == CONST_INT
3892           && INTVAL (index) < range
3893           && INTVAL (index) > -range);
3894 }
3895
3896 /* Return true if OP is a valid index scaling factor for Thumb-2 address
3897    index operand.  i.e. 1, 2, 4 or 8.  */
3898 static bool
3899 thumb2_index_mul_operand (rtx op)
3900 {
3901   HOST_WIDE_INT val;
3902   
3903   if (GET_CODE(op) != CONST_INT)
3904     return false;
3905
3906   val = INTVAL(op);
3907   return (val == 1 || val == 2 || val == 4 || val == 8);
3908 }
3909   
3910 /* Return nonzero if INDEX is a valid Thumb-2 address index operand.  */
3911 static int
3912 thumb2_legitimate_index_p (enum machine_mode mode, rtx index, int strict_p)
3913 {
3914   enum rtx_code code = GET_CODE (index);
3915
3916   /* ??? Combine arm and thumb2 coprocessor addressing modes.  */
3917   /* Standard coprocessor addressing modes.  */
3918   if (TARGET_HARD_FLOAT
3919       && (TARGET_FPA || TARGET_MAVERICK)
3920       && (GET_MODE_CLASS (mode) == MODE_FLOAT
3921           || (TARGET_MAVERICK && mode == DImode)))
3922     return (code == CONST_INT && INTVAL (index) < 1024
3923             && INTVAL (index) > -1024
3924             && (INTVAL (index) & 3) == 0);
3925
3926   if (TARGET_REALLY_IWMMXT && VALID_IWMMXT_REG_MODE (mode))
3927     {
3928       /* For DImode assume values will usually live in core regs
3929          and only allow LDRD addressing modes.  */
3930       if (!TARGET_LDRD || mode != DImode)
3931         return (code == CONST_INT
3932                 && INTVAL (index) < 1024
3933                 && INTVAL (index) > -1024
3934                 && (INTVAL (index) & 3) == 0);
3935     }
3936
3937   if (arm_address_register_rtx_p (index, strict_p)
3938       && (GET_MODE_SIZE (mode) <= 4))
3939     return 1;
3940
3941   if (mode == DImode || mode == DFmode)
3942     {
3943       HOST_WIDE_INT val = INTVAL (index);
3944       /* ??? Can we assume ldrd for thumb2?  */
3945       /* Thumb-2 ldrd only has reg+const addressing modes.  */
3946       if (code != CONST_INT)
3947         return 0;
3948
3949       /* ldrd supports offsets of +-1020.
3950          However the ldr fallback does not.  */
3951       return val > -256 && val < 256 && (val & 3) == 0;
3952     }
3953
3954   if (code == MULT)
3955     {
3956       rtx xiop0 = XEXP (index, 0);
3957       rtx xiop1 = XEXP (index, 1);
3958
3959       return ((arm_address_register_rtx_p (xiop0, strict_p)
3960                && thumb2_index_mul_operand (xiop1))
3961               || (arm_address_register_rtx_p (xiop1, strict_p)
3962                   && thumb2_index_mul_operand (xiop0)));
3963     }
3964   else if (code == ASHIFT)
3965     {
3966       rtx op = XEXP (index, 1);
3967
3968       return (arm_address_register_rtx_p (XEXP (index, 0), strict_p)
3969               && GET_CODE (op) == CONST_INT
3970               && INTVAL (op) > 0
3971               && INTVAL (op) <= 3);
3972     }
3973
3974   return (code == CONST_INT
3975           && INTVAL (index) < 4096
3976           && INTVAL (index) > -256);
3977 }
3978
3979 /* Return nonzero if X is valid as a 16-bit Thumb state base register.  */
3980 static int
3981 thumb1_base_register_rtx_p (rtx x, enum machine_mode mode, int strict_p)
3982 {
3983   int regno;
3984
3985   if (GET_CODE (x) != REG)
3986     return 0;
3987
3988   regno = REGNO (x);
3989
3990   if (strict_p)
3991     return THUMB1_REGNO_MODE_OK_FOR_BASE_P (regno, mode);
3992
3993   return (regno <= LAST_LO_REGNUM
3994           || regno > LAST_VIRTUAL_REGISTER
3995           || regno == FRAME_POINTER_REGNUM
3996           || (GET_MODE_SIZE (mode) >= 4
3997               && (regno == STACK_POINTER_REGNUM
3998                   || regno >= FIRST_PSEUDO_REGISTER
3999                   || x == hard_frame_pointer_rtx
4000                   || x == arg_pointer_rtx)));
4001 }
4002
4003 /* Return nonzero if x is a legitimate index register.  This is the case
4004    for any base register that can access a QImode object.  */
4005 inline static int
4006 thumb1_index_register_rtx_p (rtx x, int strict_p)
4007 {
4008   return thumb1_base_register_rtx_p (x, QImode, strict_p);
4009 }
4010
4011 /* Return nonzero if x is a legitimate 16-bit Thumb-state address.
4012
4013    The AP may be eliminated to either the SP or the FP, so we use the
4014    least common denominator, e.g. SImode, and offsets from 0 to 64.
4015
4016    ??? Verify whether the above is the right approach.
4017
4018    ??? Also, the FP may be eliminated to the SP, so perhaps that
4019    needs special handling also.
4020
4021    ??? Look at how the mips16 port solves this problem.  It probably uses
4022    better ways to solve some of these problems.
4023
4024    Although it is not incorrect, we don't accept&