OSDN Git Service

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