OSDN Git Service

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