OSDN Git Service

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