OSDN Git Service

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