OSDN Git Service

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