OSDN Git Service

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