OSDN Git Service

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