OSDN Git Service

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