OSDN Git Service

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