OSDN Git Service

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