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