OSDN Git Service

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