gcc/config/arm/arm.c

   1 /* Output routines for GCC for ARM.
   2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4    Free Software Foundation, Inc.
   5    Contributed by Pieter `Tiggr' Schoenmakers (rcpieter@win.tue.nl)
   6    and Martin Simmons (@harleqn.co.uk).
   7    More major hacks by Richard Earnshaw (rearnsha@arm.com).
   8
   9    This file is part of GCC.
  10
  11    GCC is free software; you can redistribute it and/or modify it
  12    under the terms of the GNU General Public License as published
  13    by the Free Software Foundation; either version 3, or (at your
  14    option) any later version.
  15
  16    GCC is distributed in the hope that it will be useful, but WITHOUT
  17    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  18    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  19    License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with GCC; see the file COPYING3.  If not see
  23    <http://www.gnu.org/licenses/>.  */
  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 "insn-config.h"
  35 #include "conditions.h"
  36 #include "output.h"
  37 #include "insn-attr.h"
  38 #include "flags.h"
  39 #include "reload.h"
  40 #include "function.h"
  41 #include "expr.h"
  42 #include "optabs.h"
  43 #include "diagnostic-core.h"
  44 #include "recog.h"
  45 #include "cgraph.h"
  46 #include "ggc.h"
  47 #include "except.h"
  48 #include "c-family/c-pragma.h"  /* ??? */
  49 #include "integrate.h"
  50 #include "tm_p.h"
  51 #include "target.h"
  52 #include "target-def.h"
  53 #include "debug.h"
  54 #include "langhooks.h"
  55 #include "df.h"
  56 #include "intl.h"
  57 #include "libfuncs.h"
  58 #include "params.h"
  59 #include "opts.h"
  60
  61 /* Forward definitions of types.  */
  62 typedef struct minipool_node    Mnode;
  63 typedef struct minipool_fixup   Mfix;
  64
  65 void (*arm_lang_output_object_attributes_hook)(void);
  66
  67 struct four_ints
  68 {
  69   int i[4];
  70 };
  71
  72 /* Forward function declarations.  */
  73 static bool arm_needs_doubleword_align (enum machine_mode, const_tree);
  74 static int arm_compute_static_chain_stack_bytes (void);
  75 static arm_stack_offsets *arm_get_frame_offsets (void);
  76 static void arm_add_gc_roots (void);
  77 static int arm_gen_constant (enum rtx_code, enum machine_mode, rtx,
  78                              HOST_WIDE_INT, rtx, rtx, int, int);
  79 static unsigned bit_count (unsigned long);
  80 static int arm_address_register_rtx_p (rtx, int);
  81 static int arm_legitimate_index_p (enum machine_mode, rtx, RTX_CODE, int);
  82 static int thumb2_legitimate_index_p (enum machine_mode, rtx, int);
  83 static int thumb1_base_register_rtx_p (rtx, enum machine_mode, int);
  84 static rtx arm_legitimize_address (rtx, rtx, enum machine_mode);
  85 static rtx thumb_legitimize_address (rtx, rtx, enum machine_mode);
  86 inline static int thumb1_index_register_rtx_p (rtx, int);
  87 static bool arm_legitimate_address_p (enum machine_mode, rtx, bool);
  88 static int thumb_far_jump_used_p (void);
  89 static bool thumb_force_lr_save (void);
  90 static rtx emit_sfm (int, int);
  91 static unsigned arm_size_return_regs (void);
  92 static bool arm_assemble_integer (rtx, unsigned int, int);
  93 static void arm_print_operand (FILE *, rtx, int);
  94 static void arm_print_operand_address (FILE *, rtx);
  95 static bool arm_print_operand_punct_valid_p (unsigned char code);
  96 static const char *fp_const_from_val (REAL_VALUE_TYPE *);
  97 static arm_cc get_arm_condition_code (rtx);
  98 static HOST_WIDE_INT int_log2 (HOST_WIDE_INT);
  99 static rtx is_jump_table (rtx);
 100 static const char *output_multi_immediate (rtx *, const char *, const char *,
 101                                            int, HOST_WIDE_INT);
 102 static const char *shift_op (rtx, HOST_WIDE_INT *);
 103 static struct machine_function *arm_init_machine_status (void);
 104 static void thumb_exit (FILE *, int);
 105 static rtx is_jump_table (rtx);
 106 static HOST_WIDE_INT get_jump_table_size (rtx);
 107 static Mnode *move_minipool_fix_forward_ref (Mnode *, Mnode *, HOST_WIDE_INT);
 108 static Mnode *add_minipool_forward_ref (Mfix *);
 109 static Mnode *move_minipool_fix_backward_ref (Mnode *, Mnode *, HOST_WIDE_INT);
 110 static Mnode *add_minipool_backward_ref (Mfix *);
 111 static void assign_minipool_offsets (Mfix *);
 112 static void arm_print_value (FILE *, rtx);
 113 static void dump_minipool (rtx);
 114 static int arm_barrier_cost (rtx);
 115 static Mfix *create_fix_barrier (Mfix *, HOST_WIDE_INT);
 116 static void push_minipool_barrier (rtx, HOST_WIDE_INT);
 117 static void push_minipool_fix (rtx, HOST_WIDE_INT, rtx *, enum machine_mode,
 118                                rtx);
 119 static void arm_reorg (void);
 120 static bool note_invalid_constants (rtx, HOST_WIDE_INT, int);
 121 static unsigned long arm_compute_save_reg0_reg12_mask (void);
 122 static unsigned long arm_compute_save_reg_mask (void);
 123 static unsigned long arm_isr_value (tree);
 124 static unsigned long arm_compute_func_type (void);
 125 static tree arm_handle_fndecl_attribute (tree *, tree, tree, int, bool *);
 126 static tree arm_handle_pcs_attribute (tree *, tree, tree, int, bool *);
 127 static tree arm_handle_isr_attribute (tree *, tree, tree, int, bool *);
 128 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
 129 static tree arm_handle_notshared_attribute (tree *, tree, tree, int, bool *);
 130 #endif
 131 static void arm_output_function_epilogue (FILE *, HOST_WIDE_INT);
 132 static void arm_output_function_prologue (FILE *, HOST_WIDE_INT);
 133 static int arm_comp_type_attributes (const_tree, const_tree);
 134 static void arm_set_default_type_attributes (tree);
 135 static int arm_adjust_cost (rtx, rtx, rtx, int);
 136 static int optimal_immediate_sequence (enum rtx_code code,
 137                                        unsigned HOST_WIDE_INT val,
 138                                        struct four_ints *return_sequence);
 139 static int optimal_immediate_sequence_1 (enum rtx_code code,
 140                                          unsigned HOST_WIDE_INT val,
 141                                          struct four_ints *return_sequence,
 142                                          int i);
 143 static int arm_get_strip_length (int);
 144 static bool arm_function_ok_for_sibcall (tree, tree);
 145 static enum machine_mode arm_promote_function_mode (const_tree,
 146                                                     enum machine_mode, int *,
 147                                                     const_tree, int);
 148 static bool arm_return_in_memory (const_tree, const_tree);
 149 static rtx arm_function_value (const_tree, const_tree, bool);
 150 static rtx arm_libcall_value_1 (enum machine_mode);
 151 static rtx arm_libcall_value (enum machine_mode, const_rtx);
 152 static bool arm_function_value_regno_p (const unsigned int);
 153 static void arm_internal_label (FILE *, const char *, unsigned long);
 154 static void arm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
 155                                  tree);
 156 static bool arm_have_conditional_execution (void);
 157 static bool arm_cannot_force_const_mem (enum machine_mode, rtx);
 158 static bool arm_legitimate_constant_p (enum machine_mode, rtx);
 159 static bool arm_rtx_costs_1 (rtx, enum rtx_code, int*, bool);
 160 static bool arm_size_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *);
 161 static bool arm_slowmul_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
 162 static bool arm_fastmul_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
 163 static bool arm_xscale_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
 164 static bool arm_9e_rtx_costs (rtx, enum rtx_code, enum rtx_code, int *, bool);
 165 static bool arm_rtx_costs (rtx, int, int, int, int *, bool);
 166 static int arm_address_cost (rtx, bool);
 167 static int arm_register_move_cost (enum machine_mode, reg_class_t, reg_class_t);
 168 static int arm_memory_move_cost (enum machine_mode, reg_class_t, bool);
 169 static bool arm_memory_load_p (rtx);
 170 static bool arm_cirrus_insn_p (rtx);
 171 static void cirrus_reorg (rtx);
 172 static void arm_init_builtins (void);
 173 static void arm_init_iwmmxt_builtins (void);
 174 static rtx safe_vector_operand (rtx, enum machine_mode);
 175 static rtx arm_expand_binop_builtin (enum insn_code, tree, rtx);
 176 static rtx arm_expand_unop_builtin (enum insn_code, tree, rtx, int);
 177 static rtx arm_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 178 static tree arm_builtin_decl (unsigned, bool);
 179 static void emit_constant_insn (rtx cond, rtx pattern);
 180 static rtx emit_set_insn (rtx, rtx);
 181 static int arm_arg_partial_bytes (cumulative_args_t, enum machine_mode,
 182                                   tree, bool);
 183 static rtx arm_function_arg (cumulative_args_t, enum machine_mode,
 184                              const_tree, bool);
 185 static void arm_function_arg_advance (cumulative_args_t, enum machine_mode,
 186                                       const_tree, bool);
 187 static unsigned int arm_function_arg_boundary (enum machine_mode, const_tree);
 188 static rtx aapcs_allocate_return_reg (enum machine_mode, const_tree,
 189                                       const_tree);
 190 static rtx aapcs_libcall_value (enum machine_mode);
 191 static int aapcs_select_return_coproc (const_tree, const_tree);
 192
 193 #ifdef OBJECT_FORMAT_ELF
 194 static void arm_elf_asm_constructor (rtx, int) ATTRIBUTE_UNUSED;
 195 static void arm_elf_asm_destructor (rtx, int) ATTRIBUTE_UNUSED;
 196 #endif
 197 #ifndef ARM_PE
 198 static void arm_encode_section_info (tree, rtx, int);
 199 #endif
 200
 201 static void arm_file_end (void);
 202 static void arm_file_start (void);
 203
 204 static void arm_setup_incoming_varargs (cumulative_args_t, enum machine_mode,
 205                                         tree, int *, int);
 206 static bool arm_pass_by_reference (cumulative_args_t,
 207                                    enum machine_mode, const_tree, bool);
 208 static bool arm_promote_prototypes (const_tree);
 209 static bool arm_default_short_enums (void);
 210 static bool arm_align_anon_bitfield (void);
 211 static bool arm_return_in_msb (const_tree);
 212 static bool arm_must_pass_in_stack (enum machine_mode, const_tree);
 213 static bool arm_return_in_memory (const_tree, const_tree);
 214 #if ARM_UNWIND_INFO
 215 static void arm_unwind_emit (FILE *, rtx);
 216 static bool arm_output_ttype (rtx);
 217 static void arm_asm_emit_except_personality (rtx);
 218 static void arm_asm_init_sections (void);
 219 #endif
 220 static rtx arm_dwarf_register_span (rtx);
 221
 222 static tree arm_cxx_guard_type (void);
 223 static bool arm_cxx_guard_mask_bit (void);
 224 static tree arm_get_cookie_size (tree);
 225 static bool arm_cookie_has_size (void);
 226 static bool arm_cxx_cdtor_returns_this (void);
 227 static bool arm_cxx_key_method_may_be_inline (void);
 228 static void arm_cxx_determine_class_data_visibility (tree);
 229 static bool arm_cxx_class_data_always_comdat (void);
 230 static bool arm_cxx_use_aeabi_atexit (void);
 231 static void arm_init_libfuncs (void);
 232 static tree arm_build_builtin_va_list (void);
 233 static void arm_expand_builtin_va_start (tree, rtx);
 234 static tree arm_gimplify_va_arg_expr (tree, tree, gimple_seq *, gimple_seq *);
 235 static void arm_option_override (void);
 236 static unsigned HOST_WIDE_INT arm_shift_truncation_mask (enum machine_mode);
 237 static bool arm_cannot_copy_insn_p (rtx);
 238 static bool arm_tls_symbol_p (rtx x);
 239 static int arm_issue_rate (void);
 240 static void arm_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
 241 static bool arm_output_addr_const_extra (FILE *, rtx);
 242 static bool arm_allocate_stack_slots_for_args (void);
 243 static const char *arm_invalid_parameter_type (const_tree t);
 244 static const char *arm_invalid_return_type (const_tree t);
 245 static tree arm_promoted_type (const_tree t);
 246 static tree arm_convert_to_type (tree type, tree expr);
 247 static bool arm_scalar_mode_supported_p (enum machine_mode);
 248 static bool arm_frame_pointer_required (void);
 249 static bool arm_can_eliminate (const int, const int);
 250 static void arm_asm_trampoline_template (FILE *);
 251 static void arm_trampoline_init (rtx, tree, rtx);
 252 static rtx arm_trampoline_adjust_address (rtx);
 253 static rtx arm_pic_static_addr (rtx orig, rtx reg);
 254 static bool cortex_a9_sched_adjust_cost (rtx, rtx, rtx, int *);
 255 static bool xscale_sched_adjust_cost (rtx, rtx, rtx, int *);
 256 static bool fa726te_sched_adjust_cost (rtx, rtx, rtx, int *);
 257 static bool arm_array_mode_supported_p (enum machine_mode,
 258                                         unsigned HOST_WIDE_INT);
 259 static enum machine_mode arm_preferred_simd_mode (enum machine_mode);
 260 static bool arm_class_likely_spilled_p (reg_class_t);
 261 static bool arm_vector_alignment_reachable (const_tree type, bool is_packed);
 262 static bool arm_builtin_support_vector_misalignment (enum machine_mode mode,
 263                                                      const_tree type,
 264                                                      int misalignment,
 265                                                      bool is_packed);
 266 static void arm_conditional_register_usage (void);
 267 static reg_class_t arm_preferred_rename_class (reg_class_t rclass);
 268 static unsigned int arm_autovectorize_vector_sizes (void);
 269 static int arm_default_branch_cost (bool, bool);
 270 static int arm_cortex_a5_branch_cost (bool, bool);
 271
 272 static bool arm_vectorize_vec_perm_const_ok (enum machine_mode vmode,
 273                                              const unsigned char *sel);
 274
 275 \f
 276 /* Table of machine attributes.  */
 277 static const struct attribute_spec arm_attribute_table[] =
 278 {
 279   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
 280        affects_type_identity } */
 281   /* Function calls made to this symbol must be done indirectly, because
 282      it may lie outside of the 26 bit addressing range of a normal function
 283      call.  */
 284   { "long_call",    0, 0, false, true,  true,  NULL, false },
 285   /* Whereas these functions are always known to reside within the 26 bit
 286      addressing range.  */
 287   { "short_call",   0, 0, false, true,  true,  NULL, false },
 288   /* Specify the procedure call conventions for a function.  */
 289   { "pcs",          1, 1, false, true,  true,  arm_handle_pcs_attribute,
 290     false },
 291   /* Interrupt Service Routines have special prologue and epilogue requirements.  */
 292   { "isr",          0, 1, false, false, false, arm_handle_isr_attribute,
 293     false },
 294   { "interrupt",    0, 1, false, false, false, arm_handle_isr_attribute,
 295     false },
 296   { "naked",        0, 0, true,  false, false, arm_handle_fndecl_attribute,
 297     false },
 298 #ifdef ARM_PE
 299   /* ARM/PE has three new attributes:
 300      interfacearm - ?
 301      dllexport - for exporting a function/variable that will live in a dll
 302      dllimport - for importing a function/variable from a dll
 303
 304      Microsoft allows multiple declspecs in one __declspec, separating
 305      them with spaces.  We do NOT support this.  Instead, use __declspec
 306      multiple times.
 307   */
 308   { "dllimport",    0, 0, true,  false, false, NULL, false },
 309   { "dllexport",    0, 0, true,  false, false, NULL, false },
 310   { "interfacearm", 0, 0, true,  false, false, arm_handle_fndecl_attribute,
 311     false },
 312 #elif TARGET_DLLIMPORT_DECL_ATTRIBUTES
 313   { "dllimport",    0, 0, false, false, false, handle_dll_attribute, false },
 314   { "dllexport",    0, 0, false, false, false, handle_dll_attribute, false },
 315   { "notshared",    0, 0, false, true, false, arm_handle_notshared_attribute,
 316     false },
 317 #endif
 318   { NULL,           0, 0, false, false, false, NULL, false }
 319 };
 320 \f
 321 /* Initialize the GCC target structure.  */
 322 #if TARGET_DLLIMPORT_DECL_ATTRIBUTES
 323 #undef  TARGET_MERGE_DECL_ATTRIBUTES
 324 #define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes
 325 #endif
 326
 327 #undef TARGET_LEGITIMIZE_ADDRESS
 328 #define TARGET_LEGITIMIZE_ADDRESS arm_legitimize_address
 329
 330 #undef  TARGET_ATTRIBUTE_TABLE
 331 #define TARGET_ATTRIBUTE_TABLE arm_attribute_table
 332
 333 #undef TARGET_ASM_FILE_START
 334 #define TARGET_ASM_FILE_START arm_file_start
 335 #undef TARGET_ASM_FILE_END
 336 #define TARGET_ASM_FILE_END arm_file_end
 337
 338 #undef  TARGET_ASM_ALIGNED_SI_OP
 339 #define TARGET_ASM_ALIGNED_SI_OP NULL
 340 #undef  TARGET_ASM_INTEGER
 341 #define TARGET_ASM_INTEGER arm_assemble_integer
 342
 343 #undef TARGET_PRINT_OPERAND
 344 #define TARGET_PRINT_OPERAND arm_print_operand
 345 #undef TARGET_PRINT_OPERAND_ADDRESS
 346 #define TARGET_PRINT_OPERAND_ADDRESS arm_print_operand_address
 347 #undef TARGET_PRINT_OPERAND_PUNCT_VALID_P
 348 #define TARGET_PRINT_OPERAND_PUNCT_VALID_P arm_print_operand_punct_valid_p
 349
 350 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
 351 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA arm_output_addr_const_extra
 352
 353 #undef  TARGET_ASM_FUNCTION_PROLOGUE
 354 #define TARGET_ASM_FUNCTION_PROLOGUE arm_output_function_prologue
 355
 356 #undef  TARGET_ASM_FUNCTION_EPILOGUE
 357 #define TARGET_ASM_FUNCTION_EPILOGUE arm_output_function_epilogue
 358
 359 #undef  TARGET_OPTION_OVERRIDE
 360 #define TARGET_OPTION_OVERRIDE arm_option_override
 361
 362 #undef  TARGET_COMP_TYPE_ATTRIBUTES
 363 #define TARGET_COMP_TYPE_ATTRIBUTES arm_comp_type_attributes
 364
 365 #undef  TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
 366 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES arm_set_default_type_attributes
 367
 368 #undef  TARGET_SCHED_ADJUST_COST
 369 #define TARGET_SCHED_ADJUST_COST arm_adjust_cost
 370
 371 #undef TARGET_REGISTER_MOVE_COST
 372 #define TARGET_REGISTER_MOVE_COST arm_register_move_cost
 373
 374 #undef TARGET_MEMORY_MOVE_COST
 375 #define TARGET_MEMORY_MOVE_COST arm_memory_move_cost
 376
 377 #undef TARGET_ENCODE_SECTION_INFO
 378 #ifdef ARM_PE
 379 #define TARGET_ENCODE_SECTION_INFO  arm_pe_encode_section_info
 380 #else
 381 #define TARGET_ENCODE_SECTION_INFO  arm_encode_section_info
 382 #endif
 383
 384 #undef  TARGET_STRIP_NAME_ENCODING
 385 #define TARGET_STRIP_NAME_ENCODING arm_strip_name_encoding
 386
 387 #undef  TARGET_ASM_INTERNAL_LABEL
 388 #define TARGET_ASM_INTERNAL_LABEL arm_internal_label
 389
 390 #undef  TARGET_FUNCTION_OK_FOR_SIBCALL
 391 #define TARGET_FUNCTION_OK_FOR_SIBCALL arm_function_ok_for_sibcall
 392
 393 #undef  TARGET_FUNCTION_VALUE
 394 #define TARGET_FUNCTION_VALUE arm_function_value
 395
 396 #undef  TARGET_LIBCALL_VALUE
 397 #define TARGET_LIBCALL_VALUE arm_libcall_value
 398
 399 #undef TARGET_FUNCTION_VALUE_REGNO_P
 400 #define TARGET_FUNCTION_VALUE_REGNO_P arm_function_value_regno_p
 401
 402 #undef  TARGET_ASM_OUTPUT_MI_THUNK
 403 #define TARGET_ASM_OUTPUT_MI_THUNK arm_output_mi_thunk
 404 #undef  TARGET_ASM_CAN_OUTPUT_MI_THUNK
 405 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
 406
 407 #undef  TARGET_RTX_COSTS
 408 #define TARGET_RTX_COSTS arm_rtx_costs
 409 #undef  TARGET_ADDRESS_COST
 410 #define TARGET_ADDRESS_COST arm_address_cost
 411
 412 #undef TARGET_SHIFT_TRUNCATION_MASK
 413 #define TARGET_SHIFT_TRUNCATION_MASK arm_shift_truncation_mask
 414 #undef TARGET_VECTOR_MODE_SUPPORTED_P
 415 #define TARGET_VECTOR_MODE_SUPPORTED_P arm_vector_mode_supported_p
 416 #undef TARGET_ARRAY_MODE_SUPPORTED_P
 417 #define TARGET_ARRAY_MODE_SUPPORTED_P arm_array_mode_supported_p
 418 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
 419 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE arm_preferred_simd_mode
 420 #undef TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
 421 #define TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES \
 422   arm_autovectorize_vector_sizes
 423
 424 #undef  TARGET_MACHINE_DEPENDENT_REORG
 425 #define TARGET_MACHINE_DEPENDENT_REORG arm_reorg
 426
 427 #undef  TARGET_INIT_BUILTINS
 428 #define TARGET_INIT_BUILTINS  arm_init_builtins
 429 #undef  TARGET_EXPAND_BUILTIN
 430 #define TARGET_EXPAND_BUILTIN arm_expand_builtin
 431 #undef  TARGET_BUILTIN_DECL
 432 #define TARGET_BUILTIN_DECL arm_builtin_decl
 433
 434 #undef TARGET_INIT_LIBFUNCS
 435 #define TARGET_INIT_LIBFUNCS arm_init_libfuncs
 436
 437 #undef TARGET_PROMOTE_FUNCTION_MODE
 438 #define TARGET_PROMOTE_FUNCTION_MODE arm_promote_function_mode
 439 #undef TARGET_PROMOTE_PROTOTYPES
 440 #define TARGET_PROMOTE_PROTOTYPES arm_promote_prototypes
 441 #undef TARGET_PASS_BY_REFERENCE
 442 #define TARGET_PASS_BY_REFERENCE arm_pass_by_reference
 443 #undef TARGET_ARG_PARTIAL_BYTES
 444 #define TARGET_ARG_PARTIAL_BYTES arm_arg_partial_bytes
 445 #undef TARGET_FUNCTION_ARG
 446 #define TARGET_FUNCTION_ARG arm_function_arg
 447 #undef TARGET_FUNCTION_ARG_ADVANCE
 448 #define TARGET_FUNCTION_ARG_ADVANCE arm_function_arg_advance
 449 #undef TARGET_FUNCTION_ARG_BOUNDARY
 450 #define TARGET_FUNCTION_ARG_BOUNDARY arm_function_arg_boundary
 451
 452 #undef  TARGET_SETUP_INCOMING_VARARGS
 453 #define TARGET_SETUP_INCOMING_VARARGS arm_setup_incoming_varargs
 454
 455 #undef TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS
 456 #define TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS arm_allocate_stack_slots_for_args
 457
 458 #undef TARGET_ASM_TRAMPOLINE_TEMPLATE
 459 #define TARGET_ASM_TRAMPOLINE_TEMPLATE arm_asm_trampoline_template
 460 #undef TARGET_TRAMPOLINE_INIT
 461 #define TARGET_TRAMPOLINE_INIT arm_trampoline_init
 462 #undef TARGET_TRAMPOLINE_ADJUST_ADDRESS
 463 #define TARGET_TRAMPOLINE_ADJUST_ADDRESS arm_trampoline_adjust_address
 464
 465 #undef TARGET_DEFAULT_SHORT_ENUMS
 466 #define TARGET_DEFAULT_SHORT_ENUMS arm_default_short_enums
 467
 468 #undef TARGET_ALIGN_ANON_BITFIELD
 469 #define TARGET_ALIGN_ANON_BITFIELD arm_align_anon_bitfield
 470
 471 #undef TARGET_NARROW_VOLATILE_BITFIELD
 472 #define TARGET_NARROW_VOLATILE_BITFIELD hook_bool_void_false
 473
 474 #undef TARGET_CXX_GUARD_TYPE
 475 #define TARGET_CXX_GUARD_TYPE arm_cxx_guard_type
 476
 477 #undef TARGET_CXX_GUARD_MASK_BIT
 478 #define TARGET_CXX_GUARD_MASK_BIT arm_cxx_guard_mask_bit
 479
 480 #undef TARGET_CXX_GET_COOKIE_SIZE
 481 #define TARGET_CXX_GET_COOKIE_SIZE arm_get_cookie_size
 482
 483 #undef TARGET_CXX_COOKIE_HAS_SIZE
 484 #define TARGET_CXX_COOKIE_HAS_SIZE arm_cookie_has_size
 485
 486 #undef TARGET_CXX_CDTOR_RETURNS_THIS
 487 #define TARGET_CXX_CDTOR_RETURNS_THIS arm_cxx_cdtor_returns_this
 488
 489 #undef TARGET_CXX_KEY_METHOD_MAY_BE_INLINE
 490 #define TARGET_CXX_KEY_METHOD_MAY_BE_INLINE arm_cxx_key_method_may_be_inline
 491
 492 #undef TARGET_CXX_USE_AEABI_ATEXIT
 493 #define TARGET_CXX_USE_AEABI_ATEXIT arm_cxx_use_aeabi_atexit
 494
 495 #undef TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY
 496 #define TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY \
 497   arm_cxx_determine_class_data_visibility
 498
 499 #undef TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT
 500 #define TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT arm_cxx_class_data_always_comdat
 501
 502 #undef TARGET_RETURN_IN_MSB
 503 #define TARGET_RETURN_IN_MSB arm_return_in_msb
 504
 505 #undef TARGET_RETURN_IN_MEMORY
 506 #define TARGET_RETURN_IN_MEMORY arm_return_in_memory
 507
 508 #undef TARGET_MUST_PASS_IN_STACK
 509 #define TARGET_MUST_PASS_IN_STACK arm_must_pass_in_stack
 510
 511 #if ARM_UNWIND_INFO
 512 #undef TARGET_ASM_UNWIND_EMIT
 513 #define TARGET_ASM_UNWIND_EMIT arm_unwind_emit
 514
 515 /* EABI unwinding tables use a different format for the typeinfo tables.  */
 516 #undef TARGET_ASM_TTYPE
 517 #define TARGET_ASM_TTYPE arm_output_ttype
 518
 519 #undef TARGET_ARM_EABI_UNWINDER
 520 #define TARGET_ARM_EABI_UNWINDER true
 521
 522 #undef TARGET_ASM_EMIT_EXCEPT_PERSONALITY
 523 #define TARGET_ASM_EMIT_EXCEPT_PERSONALITY arm_asm_emit_except_personality
 524
 525 #undef TARGET_ASM_INIT_SECTIONS
 526 #define TARGET_ASM_INIT_SECTIONS arm_asm_init_sections
 527 #endif /* ARM_UNWIND_INFO */
 528
 529 #undef TARGET_DWARF_REGISTER_SPAN
 530 #define TARGET_DWARF_REGISTER_SPAN arm_dwarf_register_span
 531
 532 #undef  TARGET_CANNOT_COPY_INSN_P
 533 #define TARGET_CANNOT_COPY_INSN_P arm_cannot_copy_insn_p
 534
 535 #ifdef HAVE_AS_TLS
 536 #undef TARGET_HAVE_TLS
 537 #define TARGET_HAVE_TLS true
 538 #endif
 539
 540 #undef TARGET_HAVE_CONDITIONAL_EXECUTION
 541 #define TARGET_HAVE_CONDITIONAL_EXECUTION arm_have_conditional_execution
 542
 543 #undef TARGET_LEGITIMATE_CONSTANT_P
 544 #define TARGET_LEGITIMATE_CONSTANT_P arm_legitimate_constant_p
 545
 546 #undef TARGET_CANNOT_FORCE_CONST_MEM
 547 #define TARGET_CANNOT_FORCE_CONST_MEM arm_cannot_force_const_mem
 548
 549 #undef TARGET_MAX_ANCHOR_OFFSET
 550 #define TARGET_MAX_ANCHOR_OFFSET 4095
 551
 552 /* The minimum is set such that the total size of the block
 553    for a particular anchor is -4088 + 1 + 4095 bytes, which is
 554    divisible by eight, ensuring natural spacing of anchors.  */
 555 #undef TARGET_MIN_ANCHOR_OFFSET
 556 #define TARGET_MIN_ANCHOR_OFFSET -4088
 557
 558 #undef TARGET_SCHED_ISSUE_RATE
 559 #define TARGET_SCHED_ISSUE_RATE arm_issue_rate
 560
 561 #undef TARGET_MANGLE_TYPE
 562 #define TARGET_MANGLE_TYPE arm_mangle_type
 563
 564 #undef TARGET_BUILD_BUILTIN_VA_LIST
 565 #define TARGET_BUILD_BUILTIN_VA_LIST arm_build_builtin_va_list
 566 #undef TARGET_EXPAND_BUILTIN_VA_START
 567 #define TARGET_EXPAND_BUILTIN_VA_START arm_expand_builtin_va_start
 568 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 569 #define TARGET_GIMPLIFY_VA_ARG_EXPR arm_gimplify_va_arg_expr
 570
 571 #ifdef HAVE_AS_TLS
 572 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
 573 #define TARGET_ASM_OUTPUT_DWARF_DTPREL arm_output_dwarf_dtprel
 574 #endif
 575
 576 #undef TARGET_LEGITIMATE_ADDRESS_P
 577 #define TARGET_LEGITIMATE_ADDRESS_P     arm_legitimate_address_p
 578
 579 #undef TARGET_INVALID_PARAMETER_TYPE
 580 #define TARGET_INVALID_PARAMETER_TYPE arm_invalid_parameter_type
 581
 582 #undef TARGET_INVALID_RETURN_TYPE
 583 #define TARGET_INVALID_RETURN_TYPE arm_invalid_return_type
 584
 585 #undef TARGET_PROMOTED_TYPE
 586 #define TARGET_PROMOTED_TYPE arm_promoted_type
 587
 588 #undef TARGET_CONVERT_TO_TYPE
 589 #define TARGET_CONVERT_TO_TYPE arm_convert_to_type
 590
 591 #undef TARGET_SCALAR_MODE_SUPPORTED_P
 592 #define TARGET_SCALAR_MODE_SUPPORTED_P arm_scalar_mode_supported_p
 593
 594 #undef TARGET_FRAME_POINTER_REQUIRED
 595 #define TARGET_FRAME_POINTER_REQUIRED arm_frame_pointer_required
 596
 597 #undef TARGET_CAN_ELIMINATE
 598 #define TARGET_CAN_ELIMINATE arm_can_eliminate
 599
 600 #undef TARGET_CONDITIONAL_REGISTER_USAGE
 601 #define TARGET_CONDITIONAL_REGISTER_USAGE arm_conditional_register_usage
 602
 603 #undef TARGET_CLASS_LIKELY_SPILLED_P
 604 #define TARGET_CLASS_LIKELY_SPILLED_P arm_class_likely_spilled_p
 605
 606 #undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
 607 #define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE \
 608   arm_vector_alignment_reachable
 609
 610 #undef TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
 611 #define TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT \
 612   arm_builtin_support_vector_misalignment
 613
 614 #undef TARGET_PREFERRED_RENAME_CLASS
 615 #define TARGET_PREFERRED_RENAME_CLASS \
 616   arm_preferred_rename_class
 617
 618 #undef TARGET_VECTORIZE_VEC_PERM_CONST_OK
 619 #define TARGET_VECTORIZE_VEC_PERM_CONST_OK \
 620   arm_vectorize_vec_perm_const_ok
 621
 622 struct gcc_target targetm = TARGET_INITIALIZER;
 623 \f
 624 /* Obstack for minipool constant handling.  */
 625 static struct obstack minipool_obstack;
 626 static char *         minipool_startobj;
 627
 628 /* The maximum number of insns skipped which
 629    will be conditionalised if possible.  */
 630 static int max_insns_skipped = 5;
 631
 632 extern FILE * asm_out_file;
 633
 634 /* True if we are currently building a constant table.  */
 635 int making_const_table;
 636
 637 /* The processor for which instructions should be scheduled.  */
 638 enum processor_type arm_tune = arm_none;
 639
 640 /* The current tuning set.  */
 641 const struct tune_params *current_tune;
 642
 643 /* Which floating point hardware to schedule for.  */
 644 int arm_fpu_attr;
 645
 646 /* Which floating popint hardware to use.  */
 647 const struct arm_fpu_desc *arm_fpu_desc;
 648
 649 /* Used for Thumb call_via trampolines.  */
 650 rtx thumb_call_via_label[14];
 651 static int thumb_call_reg_needed;
 652
 653 /* Bit values used to identify processor capabilities.  */
 654 #define FL_CO_PROC    (1 << 0)        /* Has external co-processor bus */
 655 #define FL_ARCH3M     (1 << 1)        /* Extended multiply */
 656 #define FL_MODE26     (1 << 2)        /* 26-bit mode support */
 657 #define FL_MODE32     (1 << 3)        /* 32-bit mode support */
 658 #define FL_ARCH4      (1 << 4)        /* Architecture rel 4 */
 659 #define FL_ARCH5      (1 << 5)        /* Architecture rel 5 */
 660 #define FL_THUMB      (1 << 6)        /* Thumb aware */
 661 #define FL_LDSCHED    (1 << 7)        /* Load scheduling necessary */
 662 #define FL_STRONG     (1 << 8)        /* StrongARM */
 663 #define FL_ARCH5E     (1 << 9)        /* DSP extensions to v5 */
 664 #define FL_XSCALE     (1 << 10)       /* XScale */
 665 #define FL_CIRRUS     (1 << 11)       /* Cirrus/DSP.  */
 666 #define FL_ARCH6      (1 << 12)       /* Architecture rel 6.  Adds
 667                                          media instructions.  */
 668 #define FL_VFPV2      (1 << 13)       /* Vector Floating Point V2.  */
 669 #define FL_WBUF       (1 << 14)       /* Schedule for write buffer ops.
 670                                          Note: ARM6 & 7 derivatives only.  */
 671 #define FL_ARCH6K     (1 << 15)       /* Architecture rel 6 K extensions.  */
 672 #define FL_THUMB2     (1 << 16)       /* Thumb-2.  */
 673 #define FL_NOTM       (1 << 17)       /* Instructions not present in the 'M'
 674                                          profile.  */
 675 #define FL_THUMB_DIV  (1 << 18)       /* Hardware divide (Thumb mode).  */
 676 #define FL_VFPV3      (1 << 19)       /* Vector Floating Point V3.  */
 677 #define FL_NEON       (1 << 20)       /* Neon instructions.  */
 678 #define FL_ARCH7EM    (1 << 21)       /* Instructions present in the ARMv7E-M
 679                                          architecture.  */
 680 #define FL_ARCH7      (1 << 22)       /* Architecture 7.  */
 681 #define FL_ARM_DIV    (1 << 23)       /* Hardware divide (ARM mode).  */
 682
 683 #define FL_IWMMXT     (1 << 29)       /* XScale v2 or "Intel Wireless MMX technology".  */
 684
 685 /* Flags that only effect tuning, not available instructions.  */
 686 #define FL_TUNE         (FL_WBUF | FL_VFPV2 | FL_STRONG | FL_LDSCHED \
 687                          | FL_CO_PROC)
 688
 689 #define FL_FOR_ARCH2    FL_NOTM
 690 #define FL_FOR_ARCH3    (FL_FOR_ARCH2 | FL_MODE32)
 691 #define FL_FOR_ARCH3M   (FL_FOR_ARCH3 | FL_ARCH3M)
 692 #define FL_FOR_ARCH4    (FL_FOR_ARCH3M | FL_ARCH4)
 693 #define FL_FOR_ARCH4T   (FL_FOR_ARCH4 | FL_THUMB)
 694 #define FL_FOR_ARCH5    (FL_FOR_ARCH4 | FL_ARCH5)
 695 #define FL_FOR_ARCH5T   (FL_FOR_ARCH5 | FL_THUMB)
 696 #define FL_FOR_ARCH5E   (FL_FOR_ARCH5 | FL_ARCH5E)
 697 #define FL_FOR_ARCH5TE  (FL_FOR_ARCH5E | FL_THUMB)
 698 #define FL_FOR_ARCH5TEJ FL_FOR_ARCH5TE
 699 #define FL_FOR_ARCH6    (FL_FOR_ARCH5TE | FL_ARCH6)
 700 #define FL_FOR_ARCH6J   FL_FOR_ARCH6
 701 #define FL_FOR_ARCH6K   (FL_FOR_ARCH6 | FL_ARCH6K)
 702 #define FL_FOR_ARCH6Z   FL_FOR_ARCH6
 703 #define FL_FOR_ARCH6ZK  FL_FOR_ARCH6K
 704 #define FL_FOR_ARCH6T2  (FL_FOR_ARCH6 | FL_THUMB2)
 705 #define FL_FOR_ARCH6M   (FL_FOR_ARCH6 & ~FL_NOTM)
 706 #define FL_FOR_ARCH7    ((FL_FOR_ARCH6T2 & ~FL_NOTM) | FL_ARCH7)
 707 #define FL_FOR_ARCH7A   (FL_FOR_ARCH7 | FL_NOTM | FL_ARCH6K)
 708 #define FL_FOR_ARCH7R   (FL_FOR_ARCH7A | FL_THUMB_DIV)
 709 #define FL_FOR_ARCH7M   (FL_FOR_ARCH7 | FL_THUMB_DIV)
 710 #define FL_FOR_ARCH7EM  (FL_FOR_ARCH7M | FL_ARCH7EM)
 711
 712 /* The bits in this mask specify which
 713    instructions we are allowed to generate.  */
 714 static unsigned long insn_flags = 0;
 715
 716 /* The bits in this mask specify which instruction scheduling options should
 717    be used.  */
 718 static unsigned long tune_flags = 0;
 719
 720 /* The following are used in the arm.md file as equivalents to bits
 721    in the above two flag variables.  */
 722
 723 /* Nonzero if this chip supports the ARM Architecture 3M extensions.  */
 724 int arm_arch3m = 0;
 725
 726 /* Nonzero if this chip supports the ARM Architecture 4 extensions.  */
 727 int arm_arch4 = 0;
 728
 729 /* Nonzero if this chip supports the ARM Architecture 4t extensions.  */
 730 int arm_arch4t = 0;
 731
 732 /* Nonzero if this chip supports the ARM Architecture 5 extensions.  */
 733 int arm_arch5 = 0;
 734
 735 /* Nonzero if this chip supports the ARM Architecture 5E extensions.  */
 736 int arm_arch5e = 0;
 737
 738 /* Nonzero if this chip supports the ARM Architecture 6 extensions.  */
 739 int arm_arch6 = 0;
 740
 741 /* Nonzero if this chip supports the ARM 6K extensions.  */
 742 int arm_arch6k = 0;
 743
 744 /* Nonzero if this chip supports the ARM 7 extensions.  */
 745 int arm_arch7 = 0;
 746
 747 /* Nonzero if instructions not present in the 'M' profile can be used.  */
 748 int arm_arch_notm = 0;
 749
 750 /* Nonzero if instructions present in ARMv7E-M can be used.  */
 751 int arm_arch7em = 0;
 752
 753 /* Nonzero if this chip can benefit from load scheduling.  */
 754 int arm_ld_sched = 0;
 755
 756 /* Nonzero if this chip is a StrongARM.  */
 757 int arm_tune_strongarm = 0;
 758
 759 /* Nonzero if this chip is a Cirrus variant.  */
 760 int arm_arch_cirrus = 0;
 761
 762 /* Nonzero if this chip supports Intel Wireless MMX technology.  */
 763 int arm_arch_iwmmxt = 0;
 764
 765 /* Nonzero if this chip is an XScale.  */
 766 int arm_arch_xscale = 0;
 767
 768 /* Nonzero if tuning for XScale  */
 769 int arm_tune_xscale = 0;
 770
 771 /* Nonzero if we want to tune for stores that access the write-buffer.
 772    This typically means an ARM6 or ARM7 with MMU or MPU.  */
 773 int arm_tune_wbuf = 0;
 774
 775 /* Nonzero if tuning for Cortex-A9.  */
 776 int arm_tune_cortex_a9 = 0;
 777
 778 /* Nonzero if generating Thumb instructions.  */
 779 int thumb_code = 0;
 780
 781 /* Nonzero if generating Thumb-1 instructions.  */
 782 int thumb1_code = 0;
 783
 784 /* Nonzero if we should define __THUMB_INTERWORK__ in the
 785    preprocessor.
 786    XXX This is a bit of a hack, it's intended to help work around
 787    problems in GLD which doesn't understand that armv5t code is
 788    interworking clean.  */
 789 int arm_cpp_interwork = 0;
 790
 791 /* Nonzero if chip supports Thumb 2.  */
 792 int arm_arch_thumb2;
 793
 794 /* Nonzero if chip supports integer division instruction.  */
 795 int arm_arch_arm_hwdiv;
 796 int arm_arch_thumb_hwdiv;
 797
 798 /* In case of a PRE_INC, POST_INC, PRE_DEC, POST_DEC memory reference,
 799    we must report the mode of the memory reference from
 800    TARGET_PRINT_OPERAND to TARGET_PRINT_OPERAND_ADDRESS.  */
 801 enum machine_mode output_memory_reference_mode;
 802
 803 /* The register number to be used for the PIC offset register.  */
 804 unsigned arm_pic_register = INVALID_REGNUM;
 805
 806 /* Set to 1 after arm_reorg has started.  Reset to start at the start of
 807    the next function.  */
 808 static int after_arm_reorg = 0;
 809
 810 enum arm_pcs arm_pcs_default;
 811
 812 /* For an explanation of these variables, see final_prescan_insn below.  */
 813 int arm_ccfsm_state;
 814 /* arm_current_cc is also used for Thumb-2 cond_exec blocks.  */
 815 enum arm_cond_code arm_current_cc;
 816
 817 rtx arm_target_insn;
 818 int arm_target_label;
 819 /* The number of conditionally executed insns, including the current insn.  */
 820 int arm_condexec_count = 0;
 821 /* A bitmask specifying the patterns for the IT block.
 822    Zero means do not output an IT block before this insn. */
 823 int arm_condexec_mask = 0;
 824 /* The number of bits used in arm_condexec_mask.  */
 825 int arm_condexec_masklen = 0;
 826
 827 /* The condition codes of the ARM, and the inverse function.  */
 828 static const char * const arm_condition_codes[] =
 829 {
 830   "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
 831   "hi", "ls", "ge", "lt", "gt", "le", "al", "nv"
 832 };
 833
 834 /* The register numbers in sequence, for passing to arm_gen_load_multiple.  */
 835 int arm_regs_in_sequence[] =
 836 {
 837   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15
 838 };
 839
 840 #define ARM_LSL_NAME (TARGET_UNIFIED_ASM ? "lsl" : "asl")
 841 #define streq(string1, string2) (strcmp (string1, string2) == 0)
 842
 843 #define THUMB2_WORK_REGS (0xff & ~(  (1 << THUMB_HARD_FRAME_POINTER_REGNUM) \
 844                                    | (1 << SP_REGNUM) | (1 << PC_REGNUM) \
 845                                    | (1 << PIC_OFFSET_TABLE_REGNUM)))
 846 \f
 847 /* Initialization code.  */
 848
 849 struct processors
 850 {
 851   const char *const name;
 852   enum processor_type core;
 853   const char *arch;
 854   const unsigned long flags;
 855   const struct tune_params *const tune;
 856 };
 857
 858
 859 #define ARM_PREFETCH_NOT_BENEFICIAL 0, -1, -1
 860 #define ARM_PREFETCH_BENEFICIAL(prefetch_slots,l1_size,l1_line_size) \
 861   prefetch_slots, \
 862   l1_size, \
 863   l1_line_size
 864
 865 const struct tune_params arm_slowmul_tune =
 866 {
 867   arm_slowmul_rtx_costs,
 868   NULL,
 869   3,                                            /* Constant limit.  */
 870   5,                                            /* Max cond insns.  */
 871   ARM_PREFETCH_NOT_BENEFICIAL,
 872   true,                                         /* Prefer constant pool.  */
 873   arm_default_branch_cost
 874 };
 875
 876 const struct tune_params arm_fastmul_tune =
 877 {
 878   arm_fastmul_rtx_costs,
 879   NULL,
 880   1,                                            /* Constant limit.  */
 881   5,                                            /* Max cond insns.  */
 882   ARM_PREFETCH_NOT_BENEFICIAL,
 883   true,                                         /* Prefer constant pool.  */
 884   arm_default_branch_cost
 885 };
 886
 887 /* StrongARM has early execution of branches, so a sequence that is worth
 888    skipping is shorter.  Set max_insns_skipped to a lower value.  */
 889
 890 const struct tune_params arm_strongarm_tune =
 891 {
 892   arm_fastmul_rtx_costs,
 893   NULL,
 894   1,                                            /* Constant limit.  */
 895   3,                                            /* Max cond insns.  */
 896   ARM_PREFETCH_NOT_BENEFICIAL,
 897   true,                                         /* Prefer constant pool.  */
 898   arm_default_branch_cost
 899 };
 900
 901 const struct tune_params arm_xscale_tune =
 902 {
 903   arm_xscale_rtx_costs,
 904   xscale_sched_adjust_cost,
 905   2,                                            /* Constant limit.  */
 906   3,                                            /* Max cond insns.  */
 907   ARM_PREFETCH_NOT_BENEFICIAL,
 908   true,                                         /* Prefer constant pool.  */
 909   arm_default_branch_cost
 910 };
 911
 912 const struct tune_params arm_9e_tune =
 913 {
 914   arm_9e_rtx_costs,
 915   NULL,
 916   1,                                            /* Constant limit.  */
 917   5,                                            /* Max cond insns.  */
 918   ARM_PREFETCH_NOT_BENEFICIAL,
 919   true,                                         /* Prefer constant pool.  */
 920   arm_default_branch_cost
 921 };
 922
 923 const struct tune_params arm_v6t2_tune =
 924 {
 925   arm_9e_rtx_costs,
 926   NULL,
 927   1,                                            /* Constant limit.  */
 928   5,                                            /* Max cond insns.  */
 929   ARM_PREFETCH_NOT_BENEFICIAL,
 930   false,                                        /* Prefer constant pool.  */
 931   arm_default_branch_cost
 932 };
 933
 934 /* Generic Cortex tuning.  Use more specific tunings if appropriate.  */
 935 const struct tune_params arm_cortex_tune =
 936 {
 937   arm_9e_rtx_costs,
 938   NULL,
 939   1,                                            /* Constant limit.  */
 940   5,                                            /* Max cond insns.  */
 941   ARM_PREFETCH_NOT_BENEFICIAL,
 942   false,                                        /* Prefer constant pool.  */
 943   arm_default_branch_cost
 944 };
 945
 946 /* Branches can be dual-issued on Cortex-A5, so conditional execution is
 947    less appealing.  Set max_insns_skipped to a low value.  */
 948
 949 const struct tune_params arm_cortex_a5_tune =
 950 {
 951   arm_9e_rtx_costs,
 952   NULL,
 953   1,                                            /* Constant limit.  */
 954   1,                                            /* Max cond insns.  */
 955   ARM_PREFETCH_NOT_BENEFICIAL,
 956   false,                                        /* Prefer constant pool.  */
 957   arm_cortex_a5_branch_cost
 958 };
 959
 960 const struct tune_params arm_cortex_a9_tune =
 961 {
 962   arm_9e_rtx_costs,
 963   cortex_a9_sched_adjust_cost,
 964   1,                                            /* Constant limit.  */
 965   5,                                            /* Max cond insns.  */
 966   ARM_PREFETCH_BENEFICIAL(4,32,32),
 967   false,                                        /* Prefer constant pool.  */
 968   arm_default_branch_cost
 969 };
 970
 971 const struct tune_params arm_fa726te_tune =
 972 {
 973   arm_9e_rtx_costs,
 974   fa726te_sched_adjust_cost,
 975   1,                                            /* Constant limit.  */
 976   5,                                            /* Max cond insns.  */
 977   ARM_PREFETCH_NOT_BENEFICIAL,
 978   true,                                         /* Prefer constant pool.  */
 979   arm_default_branch_cost
 980 };
 981
 982
 983 /* Not all of these give usefully different compilation alternatives,
 984    but there is no simple way of generalizing them.  */
 985 static const struct processors all_cores[] =
 986 {
 987   /* ARM Cores */
 988 #define ARM_CORE(NAME, IDENT, ARCH, FLAGS, COSTS) \
 989   {NAME, IDENT, #ARCH, FLAGS | FL_FOR_ARCH##ARCH, &arm_##COSTS##_tune},
 990 #include "arm-cores.def"
 991 #undef ARM_CORE
 992   {NULL, arm_none, NULL, 0, NULL}
 993 };
 994
 995 static const struct processors all_architectures[] =
 996 {
 997   /* ARM Architectures */
 998   /* We don't specify tuning costs here as it will be figured out
 999      from the core.  */
1000
1001 #define ARM_ARCH(NAME, CORE, ARCH, FLAGS) \
1002   {NAME, CORE, #ARCH, FLAGS, NULL},
1003 #include "arm-arches.def"
1004 #undef ARM_ARCH
1005   {NULL, arm_none, NULL, 0 , NULL}
1006 };
1007
1008
1009 /* These are populated as commandline arguments are processed, or NULL
1010    if not specified.  */
1011 static const struct processors *arm_selected_arch;
1012 static const struct processors *arm_selected_cpu;
1013 static const struct processors *arm_selected_tune;
1014
1015 /* The name of the preprocessor macro to define for this architecture.  */
1016
1017 char arm_arch_name[] = "__ARM_ARCH_0UNK__";
1018
1019 /* Available values for -mfpu=.  */
1020
1021 static const struct arm_fpu_desc all_fpus[] =
1022 {
1023 #define ARM_FPU(NAME, MODEL, REV, VFP_REGS, NEON, FP16) \
1024   { NAME, MODEL, REV, VFP_REGS, NEON, FP16 },
1025 #include "arm-fpus.def"
1026 #undef ARM_FPU
1027 };
1028
1029
1030 /* Supported TLS relocations.  */
1031
1032 enum tls_reloc {
1033   TLS_GD32,
1034   TLS_LDM32,
1035   TLS_LDO32,
1036   TLS_IE32,
1037   TLS_LE32,
1038   TLS_DESCSEQ   /* GNU scheme */
1039 };
1040
1041 /* The maximum number of insns to be used when loading a constant.  */
1042 inline static int
1043 arm_constant_limit (bool size_p)
1044 {
1045   return size_p ? 1 : current_tune->constant_limit;
1046 }
1047
1048 /* Emit an insn that's a simple single-set.  Both the operands must be known
1049    to be valid.  */
1050 inline static rtx
1051 emit_set_insn (rtx x, rtx y)
1052 {
1053   return emit_insn (gen_rtx_SET (VOIDmode, x, y));
1054 }
1055
1056 /* Return the number of bits set in VALUE.  */
1057 static unsigned
1058 bit_count (unsigned long value)
1059 {
1060   unsigned long count = 0;
1061
1062   while (value)
1063     {
1064       count++;
1065       value &= value - 1;  /* Clear the least-significant set bit.  */
1066     }
1067
1068   return count;
1069 }
1070
1071 typedef struct
1072 {
1073   enum machine_mode mode;
1074   const char *name;
1075 } arm_fixed_mode_set;
1076
1077 /* A small helper for setting fixed-point library libfuncs.  */
1078
1079 static void
1080 arm_set_fixed_optab_libfunc (optab optable, enum machine_mode mode,
1081                              const char *funcname, const char *modename,
1082                              int num_suffix)
1083 {
1084   char buffer[50];
1085
1086   if (num_suffix == 0)
1087     sprintf (buffer, "__gnu_%s%s", funcname, modename);
1088   else
1089     sprintf (buffer, "__gnu_%s%s%d", funcname, modename, num_suffix);
1090
1091   set_optab_libfunc (optable, mode, buffer);
1092 }
1093
1094 static void
1095 arm_set_fixed_conv_libfunc (convert_optab optable, enum machine_mode to,
1096                             enum machine_mode from, const char *funcname,
1097                             const char *toname, const char *fromname)
1098 {
1099   char buffer[50];
1100   const char *maybe_suffix_2 = "";
1101
1102   /* Follow the logic for selecting a "2" suffix in fixed-bit.h.  */
1103   if (ALL_FIXED_POINT_MODE_P (from) && ALL_FIXED_POINT_MODE_P (to)
1104       && UNSIGNED_FIXED_POINT_MODE_P (from) == UNSIGNED_FIXED_POINT_MODE_P (to)
1105       && ALL_FRACT_MODE_P (from) == ALL_FRACT_MODE_P (to))
1106     maybe_suffix_2 = "2";
1107
1108   sprintf (buffer, "__gnu_%s%s%s%s", funcname, fromname, toname,
1109            maybe_suffix_2);
1110
1111   set_conv_libfunc (optable, to, from, buffer);
1112 }
1113
1114 /* Set up library functions unique to ARM.  */
1115
1116 static void
1117 arm_init_libfuncs (void)
1118 {
1119   /* For Linux, we have access to kernel support for atomic operations.  */
1120   if (arm_abi == ARM_ABI_AAPCS_LINUX)
1121     init_sync_libfuncs (2 * UNITS_PER_WORD);
1122
1123   /* There are no special library functions unless we are using the
1124      ARM BPABI.  */
1125   if (!TARGET_BPABI)
1126     return;
1127
1128   /* The functions below are described in Section 4 of the "Run-Time
1129      ABI for the ARM architecture", Version 1.0.  */
1130
1131   /* Double-precision floating-point arithmetic.  Table 2.  */
1132   set_optab_libfunc (add_optab, DFmode, "__aeabi_dadd");
1133   set_optab_libfunc (sdiv_optab, DFmode, "__aeabi_ddiv");
1134   set_optab_libfunc (smul_optab, DFmode, "__aeabi_dmul");
1135   set_optab_libfunc (neg_optab, DFmode, "__aeabi_dneg");
1136   set_optab_libfunc (sub_optab, DFmode, "__aeabi_dsub");
1137
1138   /* Double-precision comparisons.  Table 3.  */
1139   set_optab_libfunc (eq_optab, DFmode, "__aeabi_dcmpeq");
1140   set_optab_libfunc (ne_optab, DFmode, NULL);
1141   set_optab_libfunc (lt_optab, DFmode, "__aeabi_dcmplt");
1142   set_optab_libfunc (le_optab, DFmode, "__aeabi_dcmple");
1143   set_optab_libfunc (ge_optab, DFmode, "__aeabi_dcmpge");
1144   set_optab_libfunc (gt_optab, DFmode, "__aeabi_dcmpgt");
1145   set_optab_libfunc (unord_optab, DFmode, "__aeabi_dcmpun");
1146
1147   /* Single-precision floating-point arithmetic.  Table 4.  */
1148   set_optab_libfunc (add_optab, SFmode, "__aeabi_fadd");
1149   set_optab_libfunc (sdiv_optab, SFmode, "__aeabi_fdiv");
1150   set_optab_libfunc (smul_optab, SFmode, "__aeabi_fmul");
1151   set_optab_libfunc (neg_optab, SFmode, "__aeabi_fneg");
1152   set_optab_libfunc (sub_optab, SFmode, "__aeabi_fsub");
1153
1154   /* Single-precision comparisons.  Table 5.  */
1155   set_optab_libfunc (eq_optab, SFmode, "__aeabi_fcmpeq");
1156   set_optab_libfunc (ne_optab, SFmode, NULL);
1157   set_optab_libfunc (lt_optab, SFmode, "__aeabi_fcmplt");
1158   set_optab_libfunc (le_optab, SFmode, "__aeabi_fcmple");
1159   set_optab_libfunc (ge_optab, SFmode, "__aeabi_fcmpge");
1160   set_optab_libfunc (gt_optab, SFmode, "__aeabi_fcmpgt");
1161   set_optab_libfunc (unord_optab, SFmode, "__aeabi_fcmpun");
1162
1163   /* Floating-point to integer conversions.  Table 6.  */
1164   set_conv_libfunc (sfix_optab, SImode, DFmode, "__aeabi_d2iz");
1165   set_conv_libfunc (ufix_optab, SImode, DFmode, "__aeabi_d2uiz");
1166   set_conv_libfunc (sfix_optab, DImode, DFmode, "__aeabi_d2lz");
1167   set_conv_libfunc (ufix_optab, DImode, DFmode, "__aeabi_d2ulz");
1168   set_conv_libfunc (sfix_optab, SImode, SFmode, "__aeabi_f2iz");
1169   set_conv_libfunc (ufix_optab, SImode, SFmode, "__aeabi_f2uiz");
1170   set_conv_libfunc (sfix_optab, DImode, SFmode, "__aeabi_f2lz");
1171   set_conv_libfunc (ufix_optab, DImode, SFmode, "__aeabi_f2ulz");
1172
1173   /* Conversions between floating types.  Table 7.  */
1174   set_conv_libfunc (trunc_optab, SFmode, DFmode, "__aeabi_d2f");
1175   set_conv_libfunc (sext_optab, DFmode, SFmode, "__aeabi_f2d");
1176
1177   /* Integer to floating-point conversions.  Table 8.  */
1178   set_conv_libfunc (sfloat_optab, DFmode, SImode, "__aeabi_i2d");
1179   set_conv_libfunc (ufloat_optab, DFmode, SImode, "__aeabi_ui2d");
1180   set_conv_libfunc (sfloat_optab, DFmode, DImode, "__aeabi_l2d");
1181   set_conv_libfunc (ufloat_optab, DFmode, DImode, "__aeabi_ul2d");
1182   set_conv_libfunc (sfloat_optab, SFmode, SImode, "__aeabi_i2f");
1183   set_conv_libfunc (ufloat_optab, SFmode, SImode, "__aeabi_ui2f");
1184   set_conv_libfunc (sfloat_optab, SFmode, DImode, "__aeabi_l2f");
1185   set_conv_libfunc (ufloat_optab, SFmode, DImode, "__aeabi_ul2f");
1186
1187   /* Long long.  Table 9.  */
1188   set_optab_libfunc (smul_optab, DImode, "__aeabi_lmul");
1189   set_optab_libfunc (sdivmod_optab, DImode, "__aeabi_ldivmod");
1190   set_optab_libfunc (udivmod_optab, DImode, "__aeabi_uldivmod");
1191   set_optab_libfunc (ashl_optab, DImode, "__aeabi_llsl");
1192   set_optab_libfunc (lshr_optab, DImode, "__aeabi_llsr");
1193   set_optab_libfunc (ashr_optab, DImode, "__aeabi_lasr");
1194   set_optab_libfunc (cmp_optab, DImode, "__aeabi_lcmp");
1195   set_optab_libfunc (ucmp_optab, DImode, "__aeabi_ulcmp");
1196
1197   /* Integer (32/32->32) division.  \S 4.3.1.  */
1198   set_optab_libfunc (sdivmod_optab, SImode, "__aeabi_idivmod");
1199   set_optab_libfunc (udivmod_optab, SImode, "__aeabi_uidivmod");
1200
1201   /* The divmod functions are designed so that they can be used for
1202      plain division, even though they return both the quotient and the
1203      remainder.  The quotient is returned in the usual location (i.e.,
1204      r0 for SImode, {r0, r1} for DImode), just as would be expected
1205      for an ordinary division routine.  Because the AAPCS calling
1206      conventions specify that all of { r0, r1, r2, r3 } are
1207      callee-saved registers, there is no need to tell the compiler
1208      explicitly that those registers are clobbered by these
1209      routines.  */
1210   set_optab_libfunc (sdiv_optab, DImode, "__aeabi_ldivmod");
1211   set_optab_libfunc (udiv_optab, DImode, "__aeabi_uldivmod");
1212
1213   /* For SImode division the ABI provides div-without-mod routines,
1214      which are faster.  */
1215   set_optab_libfunc (sdiv_optab, SImode, "__aeabi_idiv");
1216   set_optab_libfunc (udiv_optab, SImode, "__aeabi_uidiv");
1217
1218   /* We don't have mod libcalls.  Fortunately gcc knows how to use the
1219      divmod libcalls instead.  */
1220   set_optab_libfunc (smod_optab, DImode, NULL);
1221   set_optab_libfunc (umod_optab, DImode, NULL);
1222   set_optab_libfunc (smod_optab, SImode, NULL);
1223   set_optab_libfunc (umod_optab, SImode, NULL);
1224
1225   /* Half-precision float operations.  The compiler handles all operations
1226      with NULL libfuncs by converting the SFmode.  */
1227   switch (arm_fp16_format)
1228     {
1229     case ARM_FP16_FORMAT_IEEE:
1230     case ARM_FP16_FORMAT_ALTERNATIVE:
1231
1232       /* Conversions.  */
1233       set_conv_libfunc (trunc_optab, HFmode, SFmode,
1234                         (arm_fp16_format == ARM_FP16_FORMAT_IEEE
1235                          ? "__gnu_f2h_ieee"
1236                          : "__gnu_f2h_alternative"));
1237       set_conv_libfunc (sext_optab, SFmode, HFmode,
1238                         (arm_fp16_format == ARM_FP16_FORMAT_IEEE
1239                          ? "__gnu_h2f_ieee"
1240                          : "__gnu_h2f_alternative"));
1241
1242       /* Arithmetic.  */
1243       set_optab_libfunc (add_optab, HFmode, NULL);
1244       set_optab_libfunc (sdiv_optab, HFmode, NULL);
1245       set_optab_libfunc (smul_optab, HFmode, NULL);
1246       set_optab_libfunc (neg_optab, HFmode, NULL);
1247       set_optab_libfunc (sub_optab, HFmode, NULL);
1248
1249       /* Comparisons.  */
1250       set_optab_libfunc (eq_optab, HFmode, NULL);
1251       set_optab_libfunc (ne_optab, HFmode, NULL);
1252       set_optab_libfunc (lt_optab, HFmode, NULL);
1253       set_optab_libfunc (le_optab, HFmode, NULL);
1254       set_optab_libfunc (ge_optab, HFmode, NULL);
1255       set_optab_libfunc (gt_optab, HFmode, NULL);
1256       set_optab_libfunc (unord_optab, HFmode, NULL);
1257       break;
1258
1259     default:
1260       break;
1261     }
1262
1263   /* Use names prefixed with __gnu_ for fixed-point helper functions.  */
1264   {
1265     const arm_fixed_mode_set fixed_arith_modes[] =
1266       {
1267         { QQmode, "qq" },
1268         { UQQmode, "uqq" },
1269         { HQmode, "hq" },
1270         { UHQmode, "uhq" },
1271         { SQmode, "sq" },
1272         { USQmode, "usq" },
1273         { DQmode, "dq" },
1274         { UDQmode, "udq" },
1275         { TQmode, "tq" },
1276         { UTQmode, "utq" },
1277         { HAmode, "ha" },
1278         { UHAmode, "uha" },
1279         { SAmode, "sa" },
1280         { USAmode, "usa" },
1281         { DAmode, "da" },
1282         { UDAmode, "uda" },
1283         { TAmode, "ta" },
1284         { UTAmode, "uta" }
1285       };
1286     const arm_fixed_mode_set fixed_conv_modes[] =
1287       {
1288         { QQmode, "qq" },
1289         { UQQmode, "uqq" },
1290         { HQmode, "hq" },
1291         { UHQmode, "uhq" },
1292         { SQmode, "sq" },
1293         { USQmode, "usq" },
1294         { DQmode, "dq" },
1295         { UDQmode, "udq" },
1296         { TQmode, "tq" },
1297         { UTQmode, "utq" },
1298         { HAmode, "ha" },
1299         { UHAmode, "uha" },
1300         { SAmode, "sa" },
1301         { USAmode, "usa" },
1302         { DAmode, "da" },
1303         { UDAmode, "uda" },
1304         { TAmode, "ta" },
1305         { UTAmode, "uta" },
1306         { QImode, "qi" },
1307         { HImode, "hi" },
1308         { SImode, "si" },
1309         { DImode, "di" },
1310         { TImode, "ti" },
1311         { SFmode, "sf" },
1312         { DFmode, "df" }
1313       };
1314     unsigned int i, j;
1315
1316     for (i = 0; i < ARRAY_SIZE (fixed_arith_modes); i++)
1317       {
1318         arm_set_fixed_optab_libfunc (add_optab, fixed_arith_modes[i].mode,
1319                                      "add", fixed_arith_modes[i].name, 3);
1320         arm_set_fixed_optab_libfunc (ssadd_optab, fixed_arith_modes[i].mode,
1321                                      "ssadd", fixed_arith_modes[i].name, 3);
1322         arm_set_fixed_optab_libfunc (usadd_optab, fixed_arith_modes[i].mode,
1323                                      "usadd", fixed_arith_modes[i].name, 3);
1324         arm_set_fixed_optab_libfunc (sub_optab, fixed_arith_modes[i].mode,
1325                                      "sub", fixed_arith_modes[i].name, 3);
1326         arm_set_fixed_optab_libfunc (sssub_optab, fixed_arith_modes[i].mode,
1327                                      "sssub", fixed_arith_modes[i].name, 3);
1328         arm_set_fixed_optab_libfunc (ussub_optab, fixed_arith_modes[i].mode,
1329                                      "ussub", fixed_arith_modes[i].name, 3);
1330         arm_set_fixed_optab_libfunc (smul_optab, fixed_arith_modes[i].mode,
1331                                      "mul", fixed_arith_modes[i].name, 3);
1332         arm_set_fixed_optab_libfunc (ssmul_optab, fixed_arith_modes[i].mode,
1333                                      "ssmul", fixed_arith_modes[i].name, 3);
1334         arm_set_fixed_optab_libfunc (usmul_optab, fixed_arith_modes[i].mode,
1335                                      "usmul", fixed_arith_modes[i].name, 3);
1336         arm_set_fixed_optab_libfunc (sdiv_optab, fixed_arith_modes[i].mode,
1337                                      "div", fixed_arith_modes[i].name, 3);
1338         arm_set_fixed_optab_libfunc (udiv_optab, fixed_arith_modes[i].mode,
1339                                      "udiv", fixed_arith_modes[i].name, 3);
1340         arm_set_fixed_optab_libfunc (ssdiv_optab, fixed_arith_modes[i].mode,
1341                                      "ssdiv", fixed_arith_modes[i].name, 3);
1342         arm_set_fixed_optab_libfunc (usdiv_optab, fixed_arith_modes[i].mode,
1343                                      "usdiv", fixed_arith_modes[i].name, 3);
1344         arm_set_fixed_optab_libfunc (neg_optab, fixed_arith_modes[i].mode,
1345                                      "neg", fixed_arith_modes[i].name, 2);
1346         arm_set_fixed_optab_libfunc (ssneg_optab, fixed_arith_modes[i].mode,
1347                                      "ssneg", fixed_arith_modes[i].name, 2);
1348         arm_set_fixed_optab_libfunc (usneg_optab, fixed_arith_modes[i].mode,
1349                                      "usneg", fixed_arith_modes[i].name, 2);
1350         arm_set_fixed_optab_libfunc (ashl_optab, fixed_arith_modes[i].mode,
1351                                      "ashl", fixed_arith_modes[i].name, 3);
1352         arm_set_fixed_optab_libfunc (ashr_optab, fixed_arith_modes[i].mode,
1353                                      "ashr", fixed_arith_modes[i].name, 3);
1354         arm_set_fixed_optab_libfunc (lshr_optab, fixed_arith_modes[i].mode,
1355                                      "lshr", fixed_arith_modes[i].name, 3);
1356         arm_set_fixed_optab_libfunc (ssashl_optab, fixed_arith_modes[i].mode,
1357                                      "ssashl", fixed_arith_modes[i].name, 3);
1358         arm_set_fixed_optab_libfunc (usashl_optab, fixed_arith_modes[i].mode,
1359                                      "usashl", fixed_arith_modes[i].name, 3);
1360         arm_set_fixed_optab_libfunc (cmp_optab, fixed_arith_modes[i].mode,
1361                                      "cmp", fixed_arith_modes[i].name, 2);
1362       }
1363
1364     for (i = 0; i < ARRAY_SIZE (fixed_conv_modes); i++)
1365       for (j = 0; j < ARRAY_SIZE (fixed_conv_modes); j++)
1366         {
1367           if (i == j
1368               || (!ALL_FIXED_POINT_MODE_P (fixed_conv_modes[i].mode)
1369                   && !ALL_FIXED_POINT_MODE_P (fixed_conv_modes[j].mode)))
1370             continue;
1371
1372           arm_set_fixed_conv_libfunc (fract_optab, fixed_conv_modes[i].mode,
1373                                       fixed_conv_modes[j].mode, "fract",
1374                                       fixed_conv_modes[i].name,
1375                                       fixed_conv_modes[j].name);
1376           arm_set_fixed_conv_libfunc (satfract_optab,
1377                                       fixed_conv_modes[i].mode,
1378                                       fixed_conv_modes[j].mode, "satfract",
1379                                       fixed_conv_modes[i].name,
1380                                       fixed_conv_modes[j].name);
1381           arm_set_fixed_conv_libfunc (fractuns_optab,
1382                                       fixed_conv_modes[i].mode,
1383                                       fixed_conv_modes[j].mode, "fractuns",
1384                                       fixed_conv_modes[i].name,
1385                                       fixed_conv_modes[j].name);
1386           arm_set_fixed_conv_libfunc (satfractuns_optab,
1387                                       fixed_conv_modes[i].mode,
1388                                       fixed_conv_modes[j].mode, "satfractuns",
1389                                       fixed_conv_modes[i].name,
1390                                       fixed_conv_modes[j].name);
1391         }
1392   }
1393
1394   if (TARGET_AAPCS_BASED)
1395     synchronize_libfunc = init_one_libfunc ("__sync_synchronize");
1396 }
1397
1398 /* On AAPCS systems, this is the "struct __va_list".  */
1399 static GTY(()) tree va_list_type;
1400
1401 /* Return the type to use as __builtin_va_list.  */
1402 static tree
1403 arm_build_builtin_va_list (void)
1404 {
1405   tree va_list_name;
1406   tree ap_field;
1407
1408   if (!TARGET_AAPCS_BASED)
1409     return std_build_builtin_va_list ();
1410
1411   /* AAPCS \S 7.1.4 requires that va_list be a typedef for a type
1412      defined as:
1413
1414        struct __va_list
1415        {
1416          void *__ap;
1417        };
1418
1419      The C Library ABI further reinforces this definition in \S
1420      4.1.
1421
1422      We must follow this definition exactly.  The structure tag
1423      name is visible in C++ mangled names, and thus forms a part
1424      of the ABI.  The field name may be used by people who
1425      #include <stdarg.h>.  */
1426   /* Create the type.  */
1427   va_list_type = lang_hooks.types.make_type (RECORD_TYPE);
1428   /* Give it the required name.  */
1429   va_list_name = build_decl (BUILTINS_LOCATION,
1430                              TYPE_DECL,
1431                              get_identifier ("__va_list"),
1432                              va_list_type);
1433   DECL_ARTIFICIAL (va_list_name) = 1;
1434   TYPE_NAME (va_list_type) = va_list_name;
1435   TYPE_STUB_DECL (va_list_type) = va_list_name;
1436   /* Create the __ap field.  */
1437   ap_field = build_decl (BUILTINS_LOCATION,
1438                          FIELD_DECL,
1439                          get_identifier ("__ap"),
1440                          ptr_type_node);
1441   DECL_ARTIFICIAL (ap_field) = 1;
1442   DECL_FIELD_CONTEXT (ap_field) = va_list_type;
1443   TYPE_FIELDS (va_list_type) = ap_field;
1444   /* Compute its layout.  */
1445   layout_type (va_list_type);
1446
1447   return va_list_type;
1448 }
1449
1450 /* Return an expression of type "void *" pointing to the next
1451    available argument in a variable-argument list.  VALIST is the
1452    user-level va_list object, of type __builtin_va_list.  */
1453 static tree
1454 arm_extract_valist_ptr (tree valist)
1455 {
1456   if (TREE_TYPE (valist) == error_mark_node)
1457     return error_mark_node;
1458
1459   /* On an AAPCS target, the pointer is stored within "struct
1460      va_list".  */
1461   if (TARGET_AAPCS_BASED)
1462     {
1463       tree ap_field = TYPE_FIELDS (TREE_TYPE (valist));
1464       valist = build3 (COMPONENT_REF, TREE_TYPE (ap_field),
1465                        valist, ap_field, NULL_TREE);
1466     }
1467
1468   return valist;
1469 }
1470
1471 /* Implement TARGET_EXPAND_BUILTIN_VA_START.  */
1472 static void
1473 arm_expand_builtin_va_start (tree valist, rtx nextarg)
1474 {
1475   valist = arm_extract_valist_ptr (valist);
1476   std_expand_builtin_va_start (valist, nextarg);
1477 }
1478
1479 /* Implement TARGET_GIMPLIFY_VA_ARG_EXPR.  */
1480 static tree
1481 arm_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
1482                           gimple_seq *post_p)
1483 {
1484   valist = arm_extract_valist_ptr (valist);
1485   return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
1486 }
1487
1488 /* Fix up any incompatible options that the user has specified.  */
1489 static void
1490 arm_option_override (void)
1491 {
1492   if (global_options_set.x_arm_arch_option)
1493     arm_selected_arch = &all_architectures[arm_arch_option];
1494
1495   if (global_options_set.x_arm_cpu_option)
1496     arm_selected_cpu = &all_cores[(int) arm_cpu_option];
1497
1498   if (global_options_set.x_arm_tune_option)
1499     arm_selected_tune = &all_cores[(int) arm_tune_option];
1500
1501 #ifdef SUBTARGET_OVERRIDE_OPTIONS
1502   SUBTARGET_OVERRIDE_OPTIONS;
1503 #endif
1504
1505   if (arm_selected_arch)
1506     {
1507       if (arm_selected_cpu)
1508         {
1509           /* Check for conflict between mcpu and march.  */
1510           if ((arm_selected_cpu->flags ^ arm_selected_arch->flags) & ~FL_TUNE)
1511             {
1512               warning (0, "switch -mcpu=%s conflicts with -march=%s switch",
1513                        arm_selected_cpu->name, arm_selected_arch->name);
1514               /* -march wins for code generation.
1515                  -mcpu wins for default tuning.  */
1516               if (!arm_selected_tune)
1517                 arm_selected_tune = arm_selected_cpu;
1518
1519               arm_selected_cpu = arm_selected_arch;
1520             }
1521           else
1522             /* -mcpu wins.  */
1523             arm_selected_arch = NULL;
1524         }
1525       else
1526         /* Pick a CPU based on the architecture.  */
1527         arm_selected_cpu = arm_selected_arch;
1528     }
1529
1530   /* If the user did not specify a processor, choose one for them.  */
1531   if (!arm_selected_cpu)
1532     {
1533       const struct processors * sel;
1534       unsigned int        sought;
1535
1536       arm_selected_cpu = &all_cores[TARGET_CPU_DEFAULT];
1537       if (!arm_selected_cpu->name)
1538         {
1539 #ifdef SUBTARGET_CPU_DEFAULT
1540           /* Use the subtarget default CPU if none was specified by
1541              configure.  */
1542           arm_selected_cpu = &all_cores[SUBTARGET_CPU_DEFAULT];
1543 #endif
1544           /* Default to ARM6.  */
1545           if (!arm_selected_cpu->name)
1546             arm_selected_cpu = &all_cores[arm6];
1547         }
1548
1549       sel = arm_selected_cpu;
1550       insn_flags = sel->flags;
1551
1552       /* Now check to see if the user has specified some command line
1553          switch that require certain abilities from the cpu.  */
1554       sought = 0;
1555
1556       if (TARGET_INTERWORK || TARGET_THUMB)
1557         {
1558           sought |= (FL_THUMB | FL_MODE32);
1559
1560           /* There are no ARM processors that support both APCS-26 and
1561              interworking.  Therefore we force FL_MODE26 to be removed
1562              from insn_flags here (if it was set), so that the search
1563              below will always be able to find a compatible processor.  */
1564           insn_flags &= ~FL_MODE26;
1565         }
1566
1567       if (sought != 0 && ((sought & insn_flags) != sought))
1568         {
1569           /* Try to locate a CPU type that supports all of the abilities
1570              of the default CPU, plus the extra abilities requested by
1571              the user.  */
1572           for (sel = all_cores; sel->name != NULL; sel++)
1573             if ((sel->flags & sought) == (sought | insn_flags))
1574               break;
1575
1576           if (sel->name == NULL)
1577             {
1578               unsigned current_bit_count = 0;
1579               const struct processors * best_fit = NULL;
1580
1581               /* Ideally we would like to issue an error message here
1582                  saying that it was not possible to find a CPU compatible
1583                  with the default CPU, but which also supports the command
1584                  line options specified by the programmer, and so they
1585                  ought to use the -mcpu=<name> command line option to
1586                  override the default CPU type.
1587
1588                  If we cannot find a cpu that has both the
1589                  characteristics of the default cpu and the given
1590                  command line options we scan the array again looking
1591                  for a best match.  */
1592               for (sel = all_cores; sel->name != NULL; sel++)
1593                 if ((sel->flags & sought) == sought)
1594                   {
1595                     unsigned count;
1596
1597                     count = bit_count (sel->flags & insn_flags);
1598
1599                     if (count >= current_bit_count)
1600                       {
1601                         best_fit = sel;
1602                         current_bit_count = count;
1603                       }
1604                   }
1605
1606               gcc_assert (best_fit);
1607               sel = best_fit;
1608             }
1609
1610           arm_selected_cpu = sel;
1611         }
1612     }
1613
1614   gcc_assert (arm_selected_cpu);
1615   /* The selected cpu may be an architecture, so lookup tuning by core ID.  */
1616   if (!arm_selected_tune)
1617     arm_selected_tune = &all_cores[arm_selected_cpu->core];
1618
1619   sprintf (arm_arch_name, "__ARM_ARCH_%s__", arm_selected_cpu->arch);
1620   insn_flags = arm_selected_cpu->flags;
1621
1622   arm_tune = arm_selected_tune->core;
1623   tune_flags = arm_selected_tune->flags;
1624   current_tune = arm_selected_tune->tune;
1625
1626   /* Make sure that the processor choice does not conflict with any of the
1627      other command line choices.  */
1628   if (TARGET_ARM && !(insn_flags & FL_NOTM))
1629     error ("target CPU does not support ARM mode");
1630
1631   /* BPABI targets use linker tricks to allow interworking on cores
1632      without thumb support.  */
1633   if (TARGET_INTERWORK && !((insn_flags & FL_THUMB) || TARGET_BPABI))
1634     {
1635       warning (0, "target CPU does not support interworking" );
1636       target_flags &= ~MASK_INTERWORK;
1637     }
1638
1639   if (TARGET_THUMB && !(insn_flags & FL_THUMB))
1640     {
1641       warning (0, "target CPU does not support THUMB instructions");
1642       target_flags &= ~MASK_THUMB;
1643     }
1644
1645   if (TARGET_APCS_FRAME && TARGET_THUMB)
1646     {
1647       /* warning (0, "ignoring -mapcs-frame because -mthumb was used"); */
1648       target_flags &= ~MASK_APCS_FRAME;
1649     }
1650
1651   /* Callee super interworking implies thumb interworking.  Adding
1652      this to the flags here simplifies the logic elsewhere.  */
1653   if (TARGET_THUMB && TARGET_CALLEE_INTERWORKING)
1654     target_flags |= MASK_INTERWORK;
1655
1656   /* TARGET_BACKTRACE calls leaf_function_p, which causes a crash if done
1657      from here where no function is being compiled currently.  */
1658   if ((TARGET_TPCS_FRAME || TARGET_TPCS_LEAF_FRAME) && TARGET_ARM)
1659     warning (0, "enabling backtrace support is only meaningful when compiling for the Thumb");
1660
1661   if (TARGET_ARM && TARGET_CALLEE_INTERWORKING)
1662     warning (0, "enabling callee interworking support is only meaningful when compiling for the Thumb");
1663
1664   if (TARGET_APCS_STACK && !TARGET_APCS_FRAME)
1665     {
1666       warning (0, "-mapcs-stack-check incompatible with -mno-apcs-frame");
1667       target_flags |= MASK_APCS_FRAME;
1668     }
1669
1670   if (TARGET_POKE_FUNCTION_NAME)
1671     target_flags |= MASK_APCS_FRAME;
1672
1673   if (TARGET_APCS_REENT && flag_pic)
1674     error ("-fpic and -mapcs-reent are incompatible");
1675
1676   if (TARGET_APCS_REENT)
1677     warning (0, "APCS reentrant code not supported.  Ignored");
1678
1679   /* If this target is normally configured to use APCS frames, warn if they
1680      are turned off and debugging is turned on.  */
1681   if (TARGET_ARM
1682       && write_symbols != NO_DEBUG
1683       && !TARGET_APCS_FRAME
1684       && (TARGET_DEFAULT & MASK_APCS_FRAME))
1685     warning (0, "-g with -mno-apcs-frame may not give sensible debugging");
1686
1687   if (TARGET_APCS_FLOAT)
1688     warning (0, "passing floating point arguments in fp regs not yet supported");
1689
1690   if (TARGET_LITTLE_WORDS)
1691     warning (OPT_Wdeprecated, "%<mwords-little-endian%> is deprecated and "
1692              "will be removed in a future release");
1693
1694   /* Initialize boolean versions of the flags, for use in the arm.md file.  */
1695   arm_arch3m = (insn_flags & FL_ARCH3M) != 0;
1696   arm_arch4 = (insn_flags & FL_ARCH4) != 0;
1697   arm_arch4t = arm_arch4 & ((insn_flags & FL_THUMB) != 0);
1698   arm_arch5 = (insn_flags & FL_ARCH5) != 0;
1699   arm_arch5e = (insn_flags & FL_ARCH5E) != 0;
1700   arm_arch6 = (insn_flags & FL_ARCH6) != 0;
1701   arm_arch6k = (insn_flags & FL_ARCH6K) != 0;
1702   arm_arch_notm = (insn_flags & FL_NOTM) != 0;
1703   arm_arch7 = (insn_flags & FL_ARCH7) != 0;
1704   arm_arch7em = (insn_flags & FL_ARCH7EM) != 0;
1705   arm_arch_thumb2 = (insn_flags & FL_THUMB2) != 0;
1706   arm_arch_xscale = (insn_flags & FL_XSCALE) != 0;
1707   arm_arch_cirrus = (insn_flags & FL_CIRRUS) != 0;
1708
1709   arm_ld_sched = (tune_flags & FL_LDSCHED) != 0;
1710   arm_tune_strongarm = (tune_flags & FL_STRONG) != 0;
1711   thumb_code = TARGET_ARM == 0;
1712   thumb1_code = TARGET_THUMB1 != 0;
1713   arm_tune_wbuf = (tune_flags & FL_WBUF) != 0;
1714   arm_tune_xscale = (tune_flags & FL_XSCALE) != 0;
1715   arm_arch_iwmmxt = (insn_flags & FL_IWMMXT) != 0;
1716   arm_arch_thumb_hwdiv = (insn_flags & FL_THUMB_DIV) != 0;
1717   arm_arch_arm_hwdiv = (insn_flags & FL_ARM_DIV) != 0;
1718   arm_tune_cortex_a9 = (arm_tune == cortexa9) != 0;
1719
1720   /* If we are not using the default (ARM mode) section anchor offset
1721      ranges, then set the correct ranges now.  */
1722   if (TARGET_THUMB1)
1723     {
1724       /* Thumb-1 LDR instructions cannot have negative offsets.
1725          Permissible positive offset ranges are 5-bit (for byte loads),
1726          6-bit (for halfword loads), or 7-bit (for word loads).
1727          Empirical results suggest a 7-bit anchor range gives the best
1728          overall code size.  */
1729       targetm.min_anchor_offset = 0;
1730       targetm.max_anchor_offset = 127;
1731     }
1732   else if (TARGET_THUMB2)
1733     {
1734       /* The minimum is set such that the total size of the block
1735          for a particular anchor is 248 + 1 + 4095 bytes, which is
1736          divisible by eight, ensuring natural spacing of anchors.  */
1737       targetm.min_anchor_offset = -248;
1738       targetm.max_anchor_offset = 4095;
1739     }
1740
1741   /* V5 code we generate is completely interworking capable, so we turn off
1742      TARGET_INTERWORK here to avoid many tests later on.  */
1743
1744   /* XXX However, we must pass the right pre-processor defines to CPP
1745      or GLD can get confused.  This is a hack.  */
1746   if (TARGET_INTERWORK)
1747     arm_cpp_interwork = 1;
1748
1749   if (arm_arch5)
1750     target_flags &= ~MASK_INTERWORK;
1751
1752   if (TARGET_IWMMXT && !ARM_DOUBLEWORD_ALIGN)
1753     error ("iwmmxt requires an AAPCS compatible ABI for proper operation");
1754
1755   if (TARGET_IWMMXT_ABI && !TARGET_IWMMXT)
1756     error ("iwmmxt abi requires an iwmmxt capable cpu");
1757
1758   if (!global_options_set.x_arm_fpu_index)
1759     {
1760       const char *target_fpu_name;
1761       bool ok;
1762
1763 #ifdef FPUTYPE_DEFAULT
1764       target_fpu_name = FPUTYPE_DEFAULT;
1765 #else
1766       if (arm_arch_cirrus)
1767         target_fpu_name = "maverick";
1768       else
1769         target_fpu_name = "fpe2";
1770 #endif
1771
1772       ok = opt_enum_arg_to_value (OPT_mfpu_, target_fpu_name, &arm_fpu_index,
1773                                   CL_TARGET);
1774       gcc_assert (ok);
1775     }
1776
1777   arm_fpu_desc = &all_fpus[arm_fpu_index];
1778
1779   switch (arm_fpu_desc->model)
1780     {
1781     case ARM_FP_MODEL_FPA:
1782       if (arm_fpu_desc->rev == 2)
1783         arm_fpu_attr = FPU_FPE2;
1784       else if (arm_fpu_desc->rev == 3)
1785         arm_fpu_attr = FPU_FPE3;
1786       else
1787         arm_fpu_attr = FPU_FPA;
1788       break;
1789
1790     case ARM_FP_MODEL_MAVERICK:
1791       arm_fpu_attr = FPU_MAVERICK;
1792       break;
1793
1794     case ARM_FP_MODEL_VFP:
1795       arm_fpu_attr = FPU_VFP;
1796       break;
1797
1798     default:
1799       gcc_unreachable();
1800     }
1801
1802   if (TARGET_AAPCS_BASED
1803       && (arm_fpu_desc->model == ARM_FP_MODEL_FPA))
1804     error ("FPA is unsupported in the AAPCS");
1805
1806   if (TARGET_AAPCS_BASED)
1807     {
1808       if (TARGET_CALLER_INTERWORKING)
1809         error ("AAPCS does not support -mcaller-super-interworking");
1810       else
1811         if (TARGET_CALLEE_INTERWORKING)
1812           error ("AAPCS does not support -mcallee-super-interworking");
1813     }
1814
1815   /* FPA and iWMMXt are incompatible because the insn encodings overlap.
1816      VFP and iWMMXt can theoretically coexist, but it's unlikely such silicon
1817      will ever exist.  GCC makes no attempt to support this combination.  */
1818   if (TARGET_IWMMXT && !TARGET_SOFT_FLOAT)
1819     sorry ("iWMMXt and hardware floating point");
1820
1821   /* ??? iWMMXt insn patterns need auditing for Thumb-2.  */
1822   if (TARGET_THUMB2 && TARGET_IWMMXT)
1823     sorry ("Thumb-2 iWMMXt");
1824
1825   /* __fp16 support currently assumes the core has ldrh.  */
1826   if (!arm_arch4 && arm_fp16_format != ARM_FP16_FORMAT_NONE)
1827     sorry ("__fp16 and no ldrh");
1828
1829   /* If soft-float is specified then don't use FPU.  */
1830   if (TARGET_SOFT_FLOAT)
1831     arm_fpu_attr = FPU_NONE;
1832
1833   if (TARGET_AAPCS_BASED)
1834     {
1835       if (arm_abi == ARM_ABI_IWMMXT)
1836         arm_pcs_default = ARM_PCS_AAPCS_IWMMXT;
1837       else if (arm_float_abi == ARM_FLOAT_ABI_HARD
1838                && TARGET_HARD_FLOAT
1839                && TARGET_VFP)
1840         arm_pcs_default = ARM_PCS_AAPCS_VFP;
1841       else
1842         arm_pcs_default = ARM_PCS_AAPCS;
1843     }
1844   else
1845     {
1846       if (arm_float_abi == ARM_FLOAT_ABI_HARD && TARGET_VFP)
1847         sorry ("-mfloat-abi=hard and VFP");
1848
1849       if (arm_abi == ARM_ABI_APCS)
1850         arm_pcs_default = ARM_PCS_APCS;
1851       else
1852         arm_pcs_default = ARM_PCS_ATPCS;
1853     }
1854
1855   /* For arm2/3 there is no need to do any scheduling if there is only
1856      a floating point emulator, or we are doing software floating-point.  */
1857   if ((TARGET_SOFT_FLOAT
1858        || (TARGET_FPA && arm_fpu_desc->rev))
1859       && (tune_flags & FL_MODE32) == 0)
1860     flag_schedule_insns = flag_schedule_insns_after_reload = 0;
1861
1862   /* Use the cp15 method if it is available.  */
1863   if (target_thread_pointer == TP_AUTO)
1864     {
1865       if (arm_arch6k && !TARGET_THUMB1)
1866         target_thread_pointer = TP_CP15;
1867       else
1868         target_thread_pointer = TP_SOFT;
1869     }
1870
1871   if (TARGET_HARD_TP && TARGET_THUMB1)
1872     error ("can not use -mtp=cp15 with 16-bit Thumb");
1873
1874   /* Override the default structure alignment for AAPCS ABI.  */
1875   if (!global_options_set.x_arm_structure_size_boundary)
1876     {
1877       if (TARGET_AAPCS_BASED)
1878         arm_structure_size_boundary = 8;
1879     }
1880   else
1881     {
1882       if (arm_structure_size_boundary != 8
1883           && arm_structure_size_boundary != 32
1884           && !(ARM_DOUBLEWORD_ALIGN && arm_structure_size_boundary == 64))
1885         {
1886           if (ARM_DOUBLEWORD_ALIGN)
1887             warning (0,
1888                      "structure size boundary can only be set to 8, 32 or 64");
1889           else
1890             warning (0, "structure size boundary can only be set to 8 or 32");
1891           arm_structure_size_boundary
1892             = (TARGET_AAPCS_BASED ? 8 : DEFAULT_STRUCTURE_SIZE_BOUNDARY);
1893         }
1894     }
1895
1896   if (!TARGET_ARM && TARGET_VXWORKS_RTP && flag_pic)
1897     {
1898       error ("RTP PIC is incompatible with Thumb");
1899       flag_pic = 0;
1900     }
1901
1902   /* If stack checking is disabled, we can use r10 as the PIC register,
1903      which keeps r9 available.  The EABI specifies r9 as the PIC register.  */
1904   if (flag_pic && TARGET_SINGLE_PIC_BASE)
1905     {
1906       if (TARGET_VXWORKS_RTP)
1907         warning (0, "RTP PIC is incompatible with -msingle-pic-base");
1908       arm_pic_register = (TARGET_APCS_STACK || TARGET_AAPCS_BASED) ? 9 : 10;
1909     }
1910
1911   if (flag_pic && TARGET_VXWORKS_RTP)
1912     arm_pic_register = 9;
1913
1914   if (arm_pic_register_string != NULL)
1915     {
1916       int pic_register = decode_reg_name (arm_pic_register_string);
1917
1918       if (!flag_pic)
1919         warning (0, "-mpic-register= is useless without -fpic");
1920
1921       /* Prevent the user from choosing an obviously stupid PIC register.  */
1922       else if (pic_register < 0 || call_used_regs[pic_register]
1923                || pic_register == HARD_FRAME_POINTER_REGNUM
1924                || pic_register == STACK_POINTER_REGNUM
1925                || pic_register >= PC_REGNUM
1926                || (TARGET_VXWORKS_RTP
1927                    && (unsigned int) pic_register != arm_pic_register))
1928         error ("unable to use '%s' for PIC register", arm_pic_register_string);
1929       else
1930         arm_pic_register = pic_register;
1931     }
1932
1933   /* Enable -mfix-cortex-m3-ldrd by default for Cortex-M3 cores.  */
1934   if (fix_cm3_ldrd == 2)
1935     {
1936       if (arm_selected_cpu->core == cortexm3)
1937         fix_cm3_ldrd = 1;
1938       else
1939         fix_cm3_ldrd = 0;
1940     }
1941
1942   /* Enable -munaligned-access by default for
1943      - all ARMv6 architecture-based processors
1944      - ARMv7-A, ARMv7-R, and ARMv7-M architecture-based processors.
1945
1946      Disable -munaligned-access by default for
1947      - all pre-ARMv6 architecture-based processors
1948      - ARMv6-M architecture-based processors.  */
1949
1950   if (unaligned_access == 2)
1951     {
1952       if (arm_arch6 && (arm_arch_notm || arm_arch7))
1953         unaligned_access = 1;
1954       else
1955         unaligned_access = 0;
1956     }
1957   else if (unaligned_access == 1
1958            && !(arm_arch6 && (arm_arch_notm || arm_arch7)))
1959     {
1960       warning (0, "target CPU does not support unaligned accesses");
1961       unaligned_access = 0;
1962     }
1963
1964   if (TARGET_THUMB1 && flag_schedule_insns)
1965     {
1966       /* Don't warn since it's on by default in -O2.  */
1967       flag_schedule_insns = 0;
1968     }
1969
1970   if (optimize_size)
1971     {
1972       /* If optimizing for size, bump the number of instructions that we
1973          are prepared to conditionally execute (even on a StrongARM).  */
1974       max_insns_skipped = 6;
1975     }
1976   else
1977     max_insns_skipped = current_tune->max_insns_skipped;
1978
1979   /* Hot/Cold partitioning is not currently supported, since we can't
1980      handle literal pool placement in that case.  */
1981   if (flag_reorder_blocks_and_partition)
1982     {
1983       inform (input_location,
1984               "-freorder-blocks-and-partition not supported on this architecture");
1985       flag_reorder_blocks_and_partition = 0;
1986       flag_reorder_blocks = 1;
1987     }
1988
1989   if (flag_pic)
1990     /* Hoisting PIC address calculations more aggressively provides a small,
1991        but measurable, size reduction for PIC code.  Therefore, we decrease
1992        the bar for unrestricted expression hoisting to the cost of PIC address
1993        calculation, which is 2 instructions.  */
1994     maybe_set_param_value (PARAM_GCSE_UNRESTRICTED_COST, 2,
1995                            global_options.x_param_values,
1996                            global_options_set.x_param_values);
1997
1998   /* ARM EABI defaults to strict volatile bitfields.  */
1999   if (TARGET_AAPCS_BASED && flag_strict_volatile_bitfields < 0
2000       && abi_version_at_least(2))
2001     flag_strict_volatile_bitfields = 1;
2002
2003   /* Enable sw prefetching at -O3 for CPUS that have prefetch, and we have deemed
2004      it beneficial (signified by setting num_prefetch_slots to 1 or more.)  */
2005   if (flag_prefetch_loop_arrays < 0
2006       && HAVE_prefetch
2007       && optimize >= 3
2008       && current_tune->num_prefetch_slots > 0)
2009     flag_prefetch_loop_arrays = 1;
2010
2011   /* Set up parameters to be used in prefetching algorithm.  Do not override the
2012      defaults unless we are tuning for a core we have researched values for.  */
2013   if (current_tune->num_prefetch_slots > 0)
2014     maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
2015                            current_tune->num_prefetch_slots,
2016                            global_options.x_param_values,
2017                            global_options_set.x_param_values);
2018   if (current_tune->l1_cache_line_size >= 0)
2019     maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
2020                            current_tune->l1_cache_line_size,
2021                            global_options.x_param_values,
2022                            global_options_set.x_param_values);
2023   if (current_tune->l1_cache_size >= 0)
2024     maybe_set_param_value (PARAM_L1_CACHE_SIZE,
2025                            current_tune->l1_cache_size,
2026                            global_options.x_param_values,
2027                            global_options_set.x_param_values);
2028
2029   /* Register global variables with the garbage collector.  */
2030   arm_add_gc_roots ();
2031 }
2032
2033 static void
2034 arm_add_gc_roots (void)
2035 {
2036   gcc_obstack_init(&minipool_obstack);
2037   minipool_startobj = (char *) obstack_alloc (&minipool_obstack, 0);
2038 }
2039 \f
2040 /* A table of known ARM exception types.
2041    For use with the interrupt function attribute.  */
2042
2043 typedef struct
2044 {
2045   const char *const arg;
2046   const unsigned long return_value;
2047 }
2048 isr_attribute_arg;
2049
2050 static const isr_attribute_arg isr_attribute_args [] =
2051 {
2052   { "IRQ",   ARM_FT_ISR },
2053   { "irq",   ARM_FT_ISR },
2054   { "FIQ",   ARM_FT_FIQ },
2055   { "fiq",   ARM_FT_FIQ },
2056   { "ABORT", ARM_FT_ISR },
2057   { "abort", ARM_FT_ISR },
2058   { "ABORT", ARM_FT_ISR },
2059   { "abort", ARM_FT_ISR },
2060   { "UNDEF", ARM_FT_EXCEPTION },
2061   { "undef", ARM_FT_EXCEPTION },
2062   { "SWI",   ARM_FT_EXCEPTION },
2063   { "swi",   ARM_FT_EXCEPTION },
2064   { NULL,    ARM_FT_NORMAL }
2065 };
2066
2067 /* Returns the (interrupt) function type of the current
2068    function, or ARM_FT_UNKNOWN if the type cannot be determined.  */
2069
2070 static unsigned long
2071 arm_isr_value (tree argument)
2072 {
2073   const isr_attribute_arg * ptr;
2074   const char *              arg;
2075
2076   if (!arm_arch_notm)
2077     return ARM_FT_NORMAL | ARM_FT_STACKALIGN;
2078
2079   /* No argument - default to IRQ.  */
2080   if (argument == NULL_TREE)
2081     return ARM_FT_ISR;
2082
2083   /* Get the value of the argument.  */
2084   if (TREE_VALUE (argument) == NULL_TREE
2085       || TREE_CODE (TREE_VALUE (argument)) != STRING_CST)
2086     return ARM_FT_UNKNOWN;
2087
2088   arg = TREE_STRING_POINTER (TREE_VALUE (argument));
2089
2090   /* Check it against the list of known arguments.  */
2091   for (ptr = isr_attribute_args; ptr->arg != NULL; ptr++)
2092     if (streq (arg, ptr->arg))
2093       return ptr->return_value;
2094
2095   /* An unrecognized interrupt type.  */
2096   return ARM_FT_UNKNOWN;
2097 }
2098
2099 /* Computes the type of the current function.  */
2100
2101 static unsigned long
2102 arm_compute_func_type (void)
2103 {
2104   unsigned long type = ARM_FT_UNKNOWN;
2105   tree a;
2106   tree attr;
2107
2108   gcc_assert (TREE_CODE (current_function_decl) == FUNCTION_DECL);
2109
2110   /* Decide if the current function is volatile.  Such functions
2111      never return, and many memory cycles can be saved by not storing
2112      register values that will never be needed again.  This optimization
2113      was added to speed up context switching in a kernel application.  */
2114   if (optimize > 0
2115       && (TREE_NOTHROW (current_function_decl)
2116           || !(flag_unwind_tables
2117                || (flag_exceptions
2118                    && arm_except_unwind_info (&global_options) != UI_SJLJ)))
2119       && TREE_THIS_VOLATILE (current_function_decl))
2120     type |= ARM_FT_VOLATILE;
2121
2122   if (cfun->static_chain_decl != NULL)
2123     type |= ARM_FT_NESTED;
2124
2125   attr = DECL_ATTRIBUTES (current_function_decl);
2126
2127   a = lookup_attribute ("naked", attr);
2128   if (a != NULL_TREE)
2129     type |= ARM_FT_NAKED;
2130
2131   a = lookup_attribute ("isr", attr);
2132   if (a == NULL_TREE)
2133     a = lookup_attribute ("interrupt", attr);
2134
2135   if (a == NULL_TREE)
2136     type |= TARGET_INTERWORK ? ARM_FT_INTERWORKED : ARM_FT_NORMAL;
2137   else
2138     type |= arm_isr_value (TREE_VALUE (a));
2139
2140   return type;
2141 }
2142
2143 /* Returns the type of the current function.  */
2144
2145 unsigned long
2146 arm_current_func_type (void)
2147 {
2148   if (ARM_FUNC_TYPE (cfun->machine->func_type) == ARM_FT_UNKNOWN)
2149     cfun->machine->func_type = arm_compute_func_type ();
2150
2151   return cfun->machine->func_type;
2152 }
2153
2154 bool
2155 arm_allocate_stack_slots_for_args (void)
2156 {
2157   /* Naked functions should not allocate stack slots for arguments.  */
2158   return !IS_NAKED (arm_current_func_type ());
2159 }
2160
2161 \f
2162 /* Output assembler code for a block containing the constant parts
2163    of a trampoline, leaving space for the variable parts.
2164
2165    On the ARM, (if r8 is the static chain regnum, and remembering that
2166    referencing pc adds an offset of 8) the trampoline looks like:
2167            ldr          r8, [pc, #0]
2168            ldr          pc, [pc]
2169            .word        static chain value
2170            .word        function's address
2171    XXX FIXME: When the trampoline returns, r8 will be clobbered.  */
2172
2173 static void
2174 arm_asm_trampoline_template (FILE *f)
2175 {
2176   if (TARGET_ARM)
2177     {
2178       asm_fprintf (f, "\tldr\t%r, [%r, #0]\n", STATIC_CHAIN_REGNUM, PC_REGNUM);
2179       asm_fprintf (f, "\tldr\t%r, [%r, #0]\n", PC_REGNUM, PC_REGNUM);
2180     }
2181   else if (TARGET_THUMB2)
2182     {
2183       /* The Thumb-2 trampoline is similar to the arm implementation.
2184          Unlike 16-bit Thumb, we enter the stub in thumb mode.  */
2185       asm_fprintf (f, "\tldr.w\t%r, [%r, #4]\n",
2186                    STATIC_CHAIN_REGNUM, PC_REGNUM);
2187       asm_fprintf (f, "\tldr.w\t%r, [%r, #4]\n", PC_REGNUM, PC_REGNUM);
2188     }
2189   else
2190     {
2191       ASM_OUTPUT_ALIGN (f, 2);
2192       fprintf (f, "\t.code\t16\n");
2193       fprintf (f, ".Ltrampoline_start:\n");
2194       asm_fprintf (f, "\tpush\t{r0, r1}\n");
2195       asm_fprintf (f, "\tldr\tr0, [%r, #8]\n", PC_REGNUM);
2196       asm_fprintf (f, "\tmov\t%r, r0\n", STATIC_CHAIN_REGNUM);
2197       asm_fprintf (f, "\tldr\tr0, [%r, #8]\n", PC_REGNUM);
2198       asm_fprintf (f, "\tstr\tr0, [%r, #4]\n", SP_REGNUM);
2199       asm_fprintf (f, "\tpop\t{r0, %r}\n", PC_REGNUM);
2200     }
2201   assemble_aligned_integer (UNITS_PER_WORD, const0_rtx);
2202   assemble_aligned_integer (UNITS_PER_WORD, const0_rtx);
2203 }
2204
2205 /* Emit RTL insns to initialize the variable parts of a trampoline.  */
2206
2207 static void
2208 arm_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value)
2209 {
2210   rtx fnaddr, mem, a_tramp;
2211
2212   emit_block_move (m_tramp, assemble_trampoline_template (),
2213                    GEN_INT (TRAMPOLINE_SIZE), BLOCK_OP_NORMAL);
2214
2215   mem = adjust_address (m_tramp, SImode, TARGET_32BIT ? 8 : 12);
2216   emit_move_insn (mem, chain_value);
2217
2218   mem = adjust_address (m_tramp, SImode, TARGET_32BIT ? 12 : 16);
2219   fnaddr = XEXP (DECL_RTL (fndecl), 0);
2220   emit_move_insn (mem, fnaddr);
2221
2222   a_tramp = XEXP (m_tramp, 0);
2223   emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__clear_cache"),
2224                      LCT_NORMAL, VOIDmode, 2, a_tramp, Pmode,
2225                      plus_constant (a_tramp, TRAMPOLINE_SIZE), Pmode);
2226 }
2227
2228 /* Thumb trampolines should be entered in thumb mode, so set
2229    the bottom bit of the address.  */
2230
2231 static rtx
2232 arm_trampoline_adjust_address (rtx addr)
2233 {
2234   if (TARGET_THUMB)
2235     addr = expand_simple_binop (Pmode, IOR, addr, const1_rtx,
2236                                 NULL, 0, OPTAB_LIB_WIDEN);
2237   return addr;
2238 }
2239 \f
2240 /* Return 1 if it is possible to return using a single instruction.
2241    If SIBLING is non-null, this is a test for a return before a sibling
2242    call.  SIBLING is the call insn, so we can examine its register usage.  */
2243
2244 int
2245 use_return_insn (int iscond, rtx sibling)
2246 {
2247   int regno;
2248   unsigned int func_type;
2249   unsigned long saved_int_regs;
2250   unsigned HOST_WIDE_INT stack_adjust;
2251   arm_stack_offsets *offsets;
2252
2253   /* Never use a return instruction before reload has run.  */
2254   if (!reload_completed)
2255     return 0;
2256
2257   func_type = arm_current_func_type ();
2258
2259   /* Naked, volatile and stack alignment functions need special
2260      consideration.  */
2261   if (func_type & (ARM_FT_VOLATILE | ARM_FT_NAKED | ARM_FT_STACKALIGN))
2262     return 0;
2263
2264   /* So do interrupt functions that use the frame pointer and Thumb
2265      interrupt functions.  */
2266   if (IS_INTERRUPT (func_type) && (frame_pointer_needed || TARGET_THUMB))
2267     return 0;
2268
2269   offsets = arm_get_frame_offsets ();
2270   stack_adjust = offsets->outgoing_args - offsets->saved_regs;
2271
2272   /* As do variadic functions.  */
2273   if (crtl->args.pretend_args_size
2274       || cfun->machine->uses_anonymous_args
2275       /* Or if the function calls __builtin_eh_return () */
2276       || crtl->calls_eh_return
2277       /* Or if the function calls alloca */
2278       || cfun->calls_alloca
2279       /* Or if there is a stack adjustment.  However, if the stack pointer
2280          is saved on the stack, we can use a pre-incrementing stack load.  */
2281       || !(stack_adjust == 0 || (TARGET_APCS_FRAME && frame_pointer_needed
2282                                  && stack_adjust == 4)))
2283     return 0;
2284
2285   saved_int_regs = offsets->saved_regs_mask;
2286
2287   /* Unfortunately, the insn
2288
2289        ldmib sp, {..., sp, ...}
2290
2291      triggers a bug on most SA-110 based devices, such that the stack
2292      pointer won't be correctly restored if the instruction takes a
2293      page fault.  We work around this problem by popping r3 along with
2294      the other registers, since that is never slower than executing
2295      another instruction.
2296
2297      We test for !arm_arch5 here, because code for any architecture
2298      less than this could potentially be run on one of the buggy
2299      chips.  */
2300   if (stack_adjust == 4 && !arm_arch5 && TARGET_ARM)
2301     {
2302       /* Validate that r3 is a call-clobbered register (always true in
2303          the default abi) ...  */
2304       if (!call_used_regs[3])
2305         return 0;
2306
2307       /* ... that it isn't being used for a return value ... */
2308       if (arm_size_return_regs () >= (4 * UNITS_PER_WORD))
2309         return 0;
2310
2311       /* ... or for a tail-call argument ...  */
2312       if (sibling)
2313         {
2314           gcc_assert (GET_CODE (sibling) == CALL_INSN);
2315
2316           if (find_regno_fusage (sibling, USE, 3))
2317             return 0;
2318         }
2319
2320       /* ... and that there are no call-saved registers in r0-r2
2321          (always true in the default ABI).  */
2322       if (saved_int_regs & 0x7)
2323         return 0;
2324     }
2325
2326   /* Can't be done if interworking with Thumb, and any registers have been
2327      stacked.  */
2328   if (TARGET_INTERWORK && saved_int_regs != 0 && !IS_INTERRUPT(func_type))
2329     return 0;
2330
2331   /* On StrongARM, conditional returns are expensive if they aren't
2332      taken and multiple registers have been stacked.  */
2333   if (iscond && arm_tune_strongarm)
2334     {
2335       /* Conditional return when just the LR is stored is a simple
2336          conditional-load instruction, that's not expensive.  */
2337       if (saved_int_regs != 0 && saved_int_regs != (1 << LR_REGNUM))
2338         return 0;
2339
2340       if (flag_pic
2341           && arm_pic_register != INVALID_REGNUM
2342           && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM))
2343         return 0;
2344     }
2345
2346   /* If there are saved registers but the LR isn't saved, then we need
2347      two instructions for the return.  */
2348   if (saved_int_regs && !(saved_int_regs & (1 << LR_REGNUM)))
2349     return 0;
2350
2351   /* Can't be done if any of the FPA regs are pushed,
2352      since this also requires an insn.  */
2353   if (TARGET_HARD_FLOAT && TARGET_FPA)
2354     for (regno = FIRST_FPA_REGNUM; regno <= LAST_FPA_REGNUM; regno++)
2355       if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
2356         return 0;
2357
2358   /* Likewise VFP regs.  */
2359   if (TARGET_HARD_FLOAT && TARGET_VFP)
2360     for (regno = FIRST_VFP_REGNUM; regno <= LAST_VFP_REGNUM; regno++)
2361       if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
2362         return 0;
2363
2364   if (TARGET_REALLY_IWMMXT)
2365     for (regno = FIRST_IWMMXT_REGNUM; regno <= LAST_IWMMXT_REGNUM; regno++)
2366       if (df_regs_ever_live_p (regno) && ! call_used_regs[regno])
2367         return 0;
2368
2369   return 1;
2370 }
2371
2372 /* Return TRUE if int I is a valid immediate ARM constant.  */
2373
2374 int
2375 const_ok_for_arm (HOST_WIDE_INT i)
2376 {
2377   int lowbit;
2378
2379   /* For machines with >32 bit HOST_WIDE_INT, the bits above bit 31 must
2380      be all zero, or all one.  */
2381   if ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff) != 0
2382       && ((i & ~(unsigned HOST_WIDE_INT) 0xffffffff)
2383           != ((~(unsigned HOST_WIDE_INT) 0)
2384               & ~(unsigned HOST_WIDE_INT) 0xffffffff)))
2385     return FALSE;
2386
2387   i &= (unsigned HOST_WIDE_INT) 0xffffffff;
2388
2389   /* Fast return for 0 and small values.  We must do this for zero, since
2390      the code below can't handle that one case.  */
2391   if ((i & ~(unsigned HOST_WIDE_INT) 0xff) == 0)
2392     return TRUE;
2393
2394   /* Get the number of trailing zeros.  */
2395   lowbit = ffs((int) i) - 1;
2396
2397   /* Only even shifts are allowed in ARM mode so round down to the
2398      nearest even number.  */
2399   if (TARGET_ARM)
2400     lowbit &= ~1;
2401
2402   if ((i & ~(((unsigned HOST_WIDE_INT) 0xff) << lowbit)) == 0)
2403     return TRUE;
2404
2405   if (TARGET_ARM)
2406     {
2407       /* Allow rotated constants in ARM mode.  */
2408       if (lowbit <= 4
2409            && ((i & ~0xc000003f) == 0
2410                || (i & ~0xf000000f) == 0
2411                || (i & ~0xfc000003) == 0))
2412         return TRUE;
2413     }
2414   else
2415     {
2416       HOST_WIDE_INT v;
2417
2418       /* Allow repeated patterns 0x00XY00XY or 0xXYXYXYXY.  */
2419       v = i & 0xff;
2420       v |= v << 16;
2421       if (i == v || i == (v | (v << 8)))
2422         return TRUE;
2423
2424       /* Allow repeated pattern 0xXY00XY00.  */
2425       v = i & 0xff00;
2426       v |= v << 16;
2427       if (i == v)
2428         return TRUE;
2429     }
2430
2431   return FALSE;
2432 }
2433
2434 /* Return true if I is a valid constant for the operation CODE.  */
2435 int
2436 const_ok_for_op (HOST_WIDE_INT i, enum rtx_code code)
2437 {
2438   if (const_ok_for_arm (i))
2439     return 1;
2440
2441   switch (code)
2442     {
2443     case SET:
2444       /* See if we can use movw.  */
2445       if (arm_arch_thumb2 && (i & 0xffff0000) == 0)
2446         return 1;
2447       else
2448         /* Otherwise, try mvn.  */
2449         return const_ok_for_arm (ARM_SIGN_EXTEND (~i));
2450
2451     case PLUS:
2452       /* See if we can use addw or subw.  */
2453       if (TARGET_THUMB2
2454           && ((i & 0xfffff000) == 0
2455               || ((-i) & 0xfffff000) == 0))
2456         return 1;
2457       /* else fall through.  */
2458
2459     case COMPARE:
2460     case EQ:
2461     case NE:
2462     case GT:
2463     case LE:
2464     case LT:
2465     case GE:
2466     case GEU:
2467     case LTU:
2468     case GTU:
2469     case LEU:
2470     case UNORDERED:
2471     case ORDERED:
2472     case UNEQ:
2473     case UNGE:
2474     case UNLT:
2475     case UNGT:
2476     case UNLE:
2477       return const_ok_for_arm (ARM_SIGN_EXTEND (-i));
2478
2479     case MINUS:         /* Should only occur with (MINUS I reg) => rsb */
2480     case XOR:
2481       return 0;
2482
2483     case IOR:
2484       if (TARGET_THUMB2)
2485         return const_ok_for_arm (ARM_SIGN_EXTEND (~i));
2486       return 0;
2487
2488     case AND:
2489       return const_ok_for_arm (ARM_SIGN_EXTEND (~i));
2490
2491     default:
2492       gcc_unreachable ();
2493     }
2494 }
2495
2496 /* Emit a sequence of insns to handle a large constant.
2497    CODE is the code of the operation required, it can be any of SET, PLUS,
2498    IOR, AND, XOR, MINUS;
2499    MODE is the mode in which the operation is being performed;
2500    VAL is the integer to operate on;
2501    SOURCE is the other operand (a register, or a null-pointer for SET);
2502    SUBTARGETS means it is safe to create scratch registers if that will
2503    either produce a simpler sequence, or we will want to cse the values.
2504    Return value is the number of insns emitted.  */
2505
2506 /* ??? Tweak this for thumb2.  */
2507 int
2508 arm_split_constant (enum rtx_code code, enum machine_mode mode, rtx insn,
2509                     HOST_WIDE_INT val, rtx target, rtx source, int subtargets)
2510 {
2511   rtx cond;
2512
2513   if (insn && GET_CODE (PATTERN (insn)) == COND_EXEC)
2514     cond = COND_EXEC_TEST (PATTERN (insn));
2515   else
2516     cond = NULL_RTX;
2517
2518   if (subtargets || code == SET
2519       || (GET_CODE (target) == REG && GET_CODE (source) == REG
2520           && REGNO (target) != REGNO (source)))
2521     {
2522       /* After arm_reorg has been called, we can't fix up expensive
2523          constants by pushing them into memory so we must synthesize
2524          them in-line, regardless of the cost.  This is only likely to
2525          be more costly on chips that have load delay slots and we are
2526          compiling without running the scheduler (so no splitting
2527          occurred before the final instruction emission).
2528
2529          Ref: gcc -O1 -mcpu=strongarm gcc.c-torture/compile/980506-2.c
2530       */
2531       if (!after_arm_reorg
2532           && !cond
2533           && (arm_gen_constant (code, mode, NULL_RTX, val, target, source,
2534                                 1, 0)
2535               > (arm_constant_limit (optimize_function_for_size_p (cfun))
2536                  + (code != SET))))
2537         {
2538           if (code == SET)
2539             {
2540               /* Currently SET is the only monadic value for CODE, all
2541                  the rest are diadic.  */
2542               if (TARGET_USE_MOVT)
2543                 arm_emit_movpair (target, GEN_INT (val));
2544               else
2545                 emit_set_insn (target, GEN_INT (val));
2546
2547               return 1;
2548             }
2549           else
2550             {
2551               rtx temp = subtargets ? gen_reg_rtx (mode) : target;
2552
2553               if (TARGET_USE_MOVT)
2554                 arm_emit_movpair (temp, GEN_INT (val));
2555               else
2556                 emit_set_insn (temp, GEN_INT (val));
2557
2558               /* For MINUS, the value is subtracted from, since we never
2559                  have subtraction of a constant.  */
2560               if (code == MINUS)
2561                 emit_set_insn (target, gen_rtx_MINUS (mode, temp, source));
2562               else
2563                 emit_set_insn (target,
2564                                gen_rtx_fmt_ee (code, mode, source, temp));
2565               return 2;
2566             }
2567         }
2568     }
2569
2570   return arm_gen_constant (code, mode, cond, val, target, source, subtargets,
2571                            1);
2572 }
2573
2574 /* Return a sequence of integers, in RETURN_SEQUENCE that fit into
2575    ARM/THUMB2 immediates, and add up to VAL.
2576    Thr function return value gives the number of insns required.  */
2577 static int
2578 optimal_immediate_sequence (enum rtx_code code, unsigned HOST_WIDE_INT val,
2579                             struct four_ints *return_sequence)
2580 {
2581   int best_consecutive_zeros = 0;
2582   int i;
2583   int best_start = 0;
2584   int insns1, insns2;
2585   struct four_ints tmp_sequence;
2586
2587   /* If we aren't targetting ARM, the best place to start is always at
2588      the bottom, otherwise look more closely.  */
2589   if (TARGET_ARM)
2590     {
2591       for (i = 0; i < 32; i += 2)
2592         {
2593           int consecutive_zeros = 0;
2594
2595           if (!(val & (3 << i)))
2596             {
2597               while ((i < 32) && !(val & (3 << i)))
2598                 {
2599                   consecutive_zeros += 2;
2600                   i += 2;
2601                 }
2602               if (consecutive_zeros > best_consecutive_zeros)
2603                 {
2604                   best_consecutive_zeros = consecutive_zeros;
2605                   best_start = i - consecutive_zeros;
2606                 }
2607               i -= 2;
2608             }
2609         }
2610     }
2611
2612   /* So long as it won't require any more insns to do so, it's
2613      desirable to emit a small constant (in bits 0...9) in the last
2614      insn.  This way there is more chance that it can be combined with
2615      a later addressing insn to form a pre-indexed load or store
2616      operation.  Consider:
2617
2618            *((volatile int *)0xe0000100) = 1;
2619            *((volatile int *)0xe0000110) = 2;
2620
2621      We want this to wind up as:
2622
2623             mov rA, #0xe0000000
2624             mov rB, #1
2625             str rB, [rA, #0x100]
2626             mov rB, #2
2627             str rB, [rA, #0x110]
2628
2629      rather than having to synthesize both large constants from scratch.
2630
2631      Therefore, we calculate how many insns would be required to emit
2632      the constant starting from `best_start', and also starting from
2633      zero (i.e. with bit 31 first to be output).  If `best_start' doesn't
2634      yield a shorter sequence, we may as well use zero.  */
2635   insns1 = optimal_immediate_sequence_1 (code, val, return_sequence, best_start);
2636   if (best_start != 0
2637       && ((((unsigned HOST_WIDE_INT) 1) << best_start) < val))
2638     {
2639       insns2 = optimal_immediate_sequence_1 (code, val, &tmp_sequence, 0);
2640       if (insns2 <= insns1)
2641         {
2642           *return_sequence = tmp_sequence;
2643           insns1 = insns2;
2644         }
2645     }
2646
2647   return insns1;
2648 }
2649
2650 /* As for optimal_immediate_sequence, but starting at bit-position I.  */
2651 static int
2652 optimal_immediate_sequence_1 (enum rtx_code code, unsigned HOST_WIDE_INT val,
2653                              struct four_ints *return_sequence, int i)
2654 {
2655   int remainder = val & 0xffffffff;
2656   int insns = 0;
2657
2658   /* Try and find a way of doing the job in either two or three
2659      instructions.
2660
2661      In ARM mode we can use 8-bit constants, rotated to any 2-bit aligned
2662      location.  We start at position I.  This may be the MSB, or
2663      optimial_immediate_sequence may have positioned it at the largest block
2664      of zeros that are aligned on a 2-bit boundary. We then fill up the temps,
2665      wrapping around to the top of the word when we drop off the bottom.
2666      In the worst case this code should produce no more than four insns.
2667
2668      In Thumb2 mode, we can use 32/16-bit replicated constants, and 8-bit
2669      constants, shifted to any arbitrary location.  We should always start
2670      at the MSB.  */
2671   do
2672     {
2673       int end;
2674       unsigned int b1, b2, b3, b4;
2675       unsigned HOST_WIDE_INT result;
2676       int loc;
2677
2678       gcc_assert (insns < 4);
2679
2680       if (i <= 0)
2681         i += 32;
2682
2683       /* First, find the next normal 12/8-bit shifted/rotated immediate.  */
2684       if (remainder & ((TARGET_ARM ? (3 << (i - 2)) : (1 << (i - 1)))))
2685         {
2686           loc = i;
2687           if (i <= 12 && TARGET_THUMB2 && code == PLUS)
2688             /* We can use addw/subw for the last 12 bits.  */
2689             result = remainder;
2690           else
2691             {
2692               /* Use an 8-bit shifted/rotated immediate.  */
2693               end = i - 8;
2694               if (end < 0)
2695                 end += 32;
2696               result = remainder & ((0x0ff << end)
2697                                    | ((i < end) ? (0xff >> (32 - end))
2698                                                 : 0));
2699               i -= 8;
2700             }
2701         }
2702       else
2703         {
2704           /* Arm allows rotates by a multiple of two. Thumb-2 allows
2705              arbitrary shifts.  */
2706           i -= TARGET_ARM ? 2 : 1;
2707           continue;
2708         }
2709
2710       /* Next, see if we can do a better job with a thumb2 replicated
2711          constant.
2712
2713          We do it this way around to catch the cases like 0x01F001E0 where
2714          two 8-bit immediates would work, but a replicated constant would
2715          make it worse.
2716
2717          TODO: 16-bit constants that don't clear all the bits, but still win.
2718          TODO: Arithmetic splitting for set/add/sub, rather than bitwise.  */
2719       if (TARGET_THUMB2)
2720         {
2721           b1 = (remainder & 0xff000000) >> 24;
2722           b2 = (remainder & 0x00ff0000) >> 16;
2723           b3 = (remainder & 0x0000ff00) >> 8;
2724           b4 = remainder & 0xff;
2725
2726           if (loc > 24)
2727             {
2728               /* The 8-bit immediate already found clears b1 (and maybe b2),
2729                  but must leave b3 and b4 alone.  */
2730
2731               /* First try to find a 32-bit replicated constant that clears
2732                  almost everything.  We can assume that we can't do it in one,
2733                  or else we wouldn't be here.  */
2734               unsigned int tmp = b1 & b2 & b3 & b4;
2735               unsigned int tmp2 = tmp + (tmp << 8) + (tmp << 16)
2736                                   + (tmp << 24);
2737               unsigned int matching_bytes = (tmp == b1) + (tmp == b2)
2738                                             + (tmp == b3) + (tmp == b4);
2739               if (tmp
2740                   && (matching_bytes >= 3
2741                       || (matching_bytes == 2
2742                           && const_ok_for_op (remainder & ~tmp2, code))))
2743                 {
2744                   /* At least 3 of the bytes match, and the fourth has at
2745                      least as many bits set, or two of the bytes match
2746                      and it will only require one more insn to finish.  */
2747                   result = tmp2;
2748                   i = tmp != b1 ? 32
2749                       : tmp != b2 ? 24
2750                       : tmp != b3 ? 16
2751                       : 8;
2752                 }
2753
2754               /* Second, try to find a 16-bit replicated constant that can
2755                  leave three of the bytes clear.  If b2 or b4 is already
2756                  zero, then we can.  If the 8-bit from above would not
2757                  clear b2 anyway, then we still win.  */
2758               else if (b1 == b3 && (!b2 || !b4
2759                                || (remainder & 0x00ff0000 & ~result)))
2760                 {
2761                   result = remainder & 0xff00ff00;
2762                   i = 24;
2763                 }
2764             }
2765           else if (loc > 16)
2766             {
2767               /* The 8-bit immediate already found clears b2 (and maybe b3)
2768                  and we don't get here unless b1 is alredy clear, but it will
2769                  leave b4 unchanged.  */
2770
2771               /* If we can clear b2 and b4 at once, then we win, since the
2772                  8-bits couldn't possibly reach that far.  */
2773               if (b2 == b4)
2774                 {
2775                   result = remainder & 0x00ff00ff;
2776                   i = 16;
2777                 }
2778             }
2779         }
2780
2781       return_sequence->i[insns++] = result;
2782       remainder &= ~result;
2783
2784       if (code == SET || code == MINUS)
2785         code = PLUS;
2786     }
2787   while (remainder);
2788
2789   return insns;
2790 }
2791
2792 /* Emit an instruction with the indicated PATTERN.  If COND is
2793    non-NULL, conditionalize the execution of the instruction on COND
2794    being true.  */
2795
2796 static void
2797 emit_constant_insn (rtx cond, rtx pattern)
2798 {
2799   if (cond)
2800     pattern = gen_rtx_COND_EXEC (VOIDmode, copy_rtx (cond), pattern);
2801   emit_insn (pattern);
2802 }
2803
2804 /* As above, but extra parameter GENERATE which, if clear, suppresses
2805    RTL generation.  */
2806
2807 static int
2808 arm_gen_constant (enum rtx_code code, enum machine_mode mode, rtx cond,
2809                   HOST_WIDE_INT val, rtx target, rtx source, int subtargets,
2810                   int generate)
2811 {
2812   int can_invert = 0;
2813   int can_negate = 0;
2814   int final_invert = 0;
2815   int i;
2816   int set_sign_bit_copies = 0;
2817   int clear_sign_bit_copies = 0;
2818   int clear_zero_bit_copies = 0;
2819   int set_zero_bit_copies = 0;
2820   int insns = 0, neg_insns, inv_insns;
2821   unsigned HOST_WIDE_INT temp1, temp2;
2822   unsigned HOST_WIDE_INT remainder = val & 0xffffffff;
2823   struct four_ints *immediates;
2824   struct four_ints pos_immediates, neg_immediates, inv_immediates;
2825
2826   /* Find out which operations are safe for a given CODE.  Also do a quick
2827      check for degenerate cases; these can occur when DImode operations
2828      are split.  */
2829   switch (code)
2830     {
2831     case SET:
2832       can_invert = 1;
2833       break;
2834
2835     case PLUS:
2836       can_negate = 1;
2837       break;
2838
2839     case IOR:
2840       if (remainder == 0xffffffff)
2841         {
2842           if (generate)
2843             emit_constant_insn (cond,
2844                                 gen_rtx_SET (VOIDmode, target,
2845                                              GEN_INT (ARM_SIGN_EXTEND (val))));
2846           return 1;
2847         }
2848
2849       if (remainder == 0)
2850         {
2851           if (reload_completed && rtx_equal_p (target, source))
2852             return 0;
2853
2854           if (generate)
2855             emit_constant_insn (cond,
2856                                 gen_rtx_SET (VOIDmode, target, source));
2857           return 1;
2858         }
2859       break;
2860
2861     case AND:
2862       if (remainder == 0)
2863         {
2864           if (generate)
2865             emit_constant_insn (cond,
2866                                 gen_rtx_SET (VOIDmode, target, const0_rtx));
2867           return 1;
2868         }
2869       if (remainder == 0xffffffff)
2870         {
2871           if (reload_completed && rtx_equal_p (target, source))
2872             return 0;
2873           if (generate)
2874             emit_constant_insn (cond,
2875                                 gen_rtx_SET (VOIDmode, target, source));
2876           return 1;
2877         }
2878       can_invert = 1;
2879       break;
2880
2881     case XOR:
2882       if (remainder == 0)
2883         {
2884           if (reload_completed && rtx_equal_p (target, source))
2885             return 0;
2886           if (generate)
2887             emit_constant_insn (cond,
2888                                 gen_rtx_SET (VOIDmode, target, source));
2889           return 1;
2890         }
2891
2892       if (remainder == 0xffffffff)
2893         {
2894           if (generate)
2895             emit_constant_insn (cond,
2896                                 gen_rtx_SET (VOIDmode, target,
2897                                              gen_rtx_NOT (mode, source)));
2898           return 1;
2899         }
2900       final_invert = 1;
2901       break;
2902
2903     case MINUS:
2904       /* We treat MINUS as (val - source), since (source - val) is always
2905          passed as (source + (-val)).  */
2906       if (remainder == 0)
2907         {
2908           if (generate)
2909             emit_constant_insn (cond,
2910                                 gen_rtx_SET (VOIDmode, target,
2911                                              gen_rtx_NEG (mode, source)));
2912           return 1;
2913         }
2914       if (const_ok_for_arm (val))
2915         {
2916           if (generate)
2917             emit_constant_insn (cond,
2918                                 gen_rtx_SET (VOIDmode, target,
2919                                              gen_rtx_MINUS (mode, GEN_INT (val),
2920                                                             source)));
2921           return 1;
2922         }
2923
2924       break;
2925
2926     default:
2927       gcc_unreachable ();
2928     }
2929
2930   /* If we can do it in one insn get out quickly.  */
2931   if (const_ok_for_op (val, code))
2932     {
2933       if (generate)
2934         emit_constant_insn (cond,
2935                             gen_rtx_SET (VOIDmode, target,
2936                                          (source
2937                                           ? gen_rtx_fmt_ee (code, mode, source,
2938                                                             GEN_INT (val))
2939                                           : GEN_INT (val))));
2940       return 1;
2941     }
2942
2943   /* Calculate a few attributes that may be useful for specific
2944      optimizations.  */
2945   /* Count number of leading zeros.  */
2946   for (i = 31; i >= 0; i--)
2947     {
2948       if ((remainder & (1 << i)) == 0)
2949         clear_sign_bit_copies++;
2950       else
2951         break;
2952     }
2953
2954   /* Count number of leading 1's.  */
2955   for (i = 31; i >= 0; i--)
2956     {
2957       if ((remainder & (1 << i)) != 0)
2958         set_sign_bit_copies++;
2959       else
2960         break;
2961     }
2962
2963   /* Count number of trailing zero's.  */
2964   for (i = 0; i <= 31; i++)
2965     {
2966       if ((remainder & (1 << i)) == 0)
2967         clear_zero_bit_copies++;
2968       else
2969         break;
2970     }
2971
2972   /* Count number of trailing 1's.  */
2973   for (i = 0; i <= 31; i++)
2974     {
2975       if ((remainder & (1 << i)) != 0)
2976         set_zero_bit_copies++;
2977       else
2978         break;
2979     }
2980
2981   switch (code)
2982     {
2983     case SET:
2984       /* See if we can do this by sign_extending a constant that is known
2985          to be negative.  This is a good, way of doing it, since the shift
2986          may well merge into a subsequent insn.  */
2987       if (set_sign_bit_copies > 1)
2988         {
2989           if (const_ok_for_arm
2990               (temp1 = ARM_SIGN_EXTEND (remainder
2991                                         << (set_sign_bit_copies - 1))))
2992             {
2993               if (generate)
2994                 {
2995                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
2996                   emit_constant_insn (cond,
2997                                       gen_rtx_SET (VOIDmode, new_src,
2998                                                    GEN_INT (temp1)));
2999                   emit_constant_insn (cond,
3000                                       gen_ashrsi3 (target, new_src,
3001                                                    GEN_INT (set_sign_bit_copies - 1)));
3002                 }
3003               return 2;
3004             }
3005           /* For an inverted constant, we will need to set the low bits,
3006              these will be shifted out of harm's way.  */
3007           temp1 |= (1 << (set_sign_bit_copies - 1)) - 1;
3008           if (const_ok_for_arm (~temp1))
3009             {
3010               if (generate)
3011                 {
3012                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3013                   emit_constant_insn (cond,
3014                                       gen_rtx_SET (VOIDmode, new_src,
3015                                                    GEN_INT (temp1)));
3016                   emit_constant_insn (cond,
3017                                       gen_ashrsi3 (target, new_src,
3018                                                    GEN_INT (set_sign_bit_copies - 1)));
3019                 }
3020               return 2;
3021             }
3022         }
3023
3024       /* See if we can calculate the value as the difference between two
3025          valid immediates.  */
3026       if (clear_sign_bit_copies + clear_zero_bit_copies <= 16)
3027         {
3028           int topshift = clear_sign_bit_copies & ~1;
3029
3030           temp1 = ARM_SIGN_EXTEND ((remainder + (0x00800000 >> topshift))
3031                                    & (0xff000000 >> topshift));
3032
3033           /* If temp1 is zero, then that means the 9 most significant
3034              bits of remainder were 1 and we've caused it to overflow.
3035              When topshift is 0 we don't need to do anything since we
3036              can borrow from 'bit 32'.  */
3037           if (temp1 == 0 && topshift != 0)
3038             temp1 = 0x80000000 >> (topshift - 1);
3039
3040           temp2 = ARM_SIGN_EXTEND (temp1 - remainder);
3041
3042           if (const_ok_for_arm (temp2))
3043             {
3044               if (generate)
3045                 {
3046                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3047                   emit_constant_insn (cond,
3048                                       gen_rtx_SET (VOIDmode, new_src,
3049                                                    GEN_INT (temp1)));
3050                   emit_constant_insn (cond,
3051                                       gen_addsi3 (target, new_src,
3052                                                   GEN_INT (-temp2)));
3053                 }
3054
3055               return 2;
3056             }
3057         }
3058
3059       /* See if we can generate this by setting the bottom (or the top)
3060          16 bits, and then shifting these into the other half of the
3061          word.  We only look for the simplest cases, to do more would cost
3062          too much.  Be careful, however, not to generate this when the
3063          alternative would take fewer insns.  */
3064       if (val & 0xffff0000)
3065         {
3066           temp1 = remainder & 0xffff0000;
3067           temp2 = remainder & 0x0000ffff;
3068
3069           /* Overlaps outside this range are best done using other methods.  */
3070           for (i = 9; i < 24; i++)
3071             {
3072               if ((((temp2 | (temp2 << i)) & 0xffffffff) == remainder)
3073                   && !const_ok_for_arm (temp2))
3074                 {
3075                   rtx new_src = (subtargets
3076                                  ? (generate ? gen_reg_rtx (mode) : NULL_RTX)
3077                                  : target);
3078                   insns = arm_gen_constant (code, mode, cond, temp2, new_src,
3079                                             source, subtargets, generate);
3080                   source = new_src;
3081                   if (generate)
3082                     emit_constant_insn
3083                       (cond,
3084                        gen_rtx_SET
3085                        (VOIDmode, target,
3086                         gen_rtx_IOR (mode,
3087                                      gen_rtx_ASHIFT (mode, source,
3088                                                      GEN_INT (i)),
3089                                      source)));
3090                   return insns + 1;
3091                 }
3092             }
3093
3094           /* Don't duplicate cases already considered.  */
3095           for (i = 17; i < 24; i++)
3096             {
3097               if (((temp1 | (temp1 >> i)) == remainder)
3098                   && !const_ok_for_arm (temp1))
3099                 {
3100                   rtx new_src = (subtargets
3101                                  ? (generate ? gen_reg_rtx (mode) : NULL_RTX)
3102                                  : target);
3103                   insns = arm_gen_constant (code, mode, cond, temp1, new_src,
3104                                             source, subtargets, generate);
3105                   source = new_src;
3106                   if (generate)
3107                     emit_constant_insn
3108                       (cond,
3109                        gen_rtx_SET (VOIDmode, target,
3110                                     gen_rtx_IOR
3111                                     (mode,
3112                                      gen_rtx_LSHIFTRT (mode, source,
3113                                                        GEN_INT (i)),
3114                                      source)));
3115                   return insns + 1;
3116                 }
3117             }
3118         }
3119       break;
3120
3121     case IOR:
3122     case XOR:
3123       /* If we have IOR or XOR, and the constant can be loaded in a
3124          single instruction, and we can find a temporary to put it in,
3125          then this can be done in two instructions instead of 3-4.  */
3126       if (subtargets
3127           /* TARGET can't be NULL if SUBTARGETS is 0 */
3128           || (reload_completed && !reg_mentioned_p (target, source)))
3129         {
3130           if (const_ok_for_arm (ARM_SIGN_EXTEND (~val)))
3131             {
3132               if (generate)
3133                 {
3134                   rtx sub = subtargets ? gen_reg_rtx (mode) : target;
3135
3136                   emit_constant_insn (cond,
3137                                       gen_rtx_SET (VOIDmode, sub,
3138                                                    GEN_INT (val)));
3139                   emit_constant_insn (cond,
3140                                       gen_rtx_SET (VOIDmode, target,
3141                                                    gen_rtx_fmt_ee (code, mode,
3142                                                                    source, sub)));
3143                 }
3144               return 2;
3145             }
3146         }
3147
3148       if (code == XOR)
3149         break;
3150
3151       /*  Convert.
3152           x = y | constant ( which is composed of set_sign_bit_copies of leading 1s
3153                              and the remainder 0s for e.g. 0xfff00000)
3154           x = ~(~(y ashift set_sign_bit_copies) lshiftrt set_sign_bit_copies)
3155
3156           This can be done in 2 instructions by using shifts with mov or mvn.
3157           e.g. for
3158           x = x | 0xfff00000;
3159           we generate.
3160           mvn   r0, r0, asl #12
3161           mvn   r0, r0, lsr #12  */
3162       if (set_sign_bit_copies > 8
3163           && (val & (-1 << (32 - set_sign_bit_copies))) == val)
3164         {
3165           if (generate)
3166             {
3167               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
3168               rtx shift = GEN_INT (set_sign_bit_copies);
3169
3170               emit_constant_insn
3171                 (cond,
3172                  gen_rtx_SET (VOIDmode, sub,
3173                               gen_rtx_NOT (mode,
3174                                            gen_rtx_ASHIFT (mode,
3175                                                            source,
3176                                                            shift))));
3177               emit_constant_insn
3178                 (cond,
3179                  gen_rtx_SET (VOIDmode, target,
3180                               gen_rtx_NOT (mode,
3181                                            gen_rtx_LSHIFTRT (mode, sub,
3182                                                              shift))));
3183             }
3184           return 2;
3185         }
3186
3187       /* Convert
3188           x = y | constant (which has set_zero_bit_copies number of trailing ones).
3189            to
3190           x = ~((~y lshiftrt set_zero_bit_copies) ashift set_zero_bit_copies).
3191
3192           For eg. r0 = r0 | 0xfff
3193                mvn      r0, r0, lsr #12
3194                mvn      r0, r0, asl #12
3195
3196       */
3197       if (set_zero_bit_copies > 8
3198           && (remainder & ((1 << set_zero_bit_copies) - 1)) == remainder)
3199         {
3200           if (generate)
3201             {
3202               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
3203               rtx shift = GEN_INT (set_zero_bit_copies);
3204
3205               emit_constant_insn
3206                 (cond,
3207                  gen_rtx_SET (VOIDmode, sub,
3208                               gen_rtx_NOT (mode,
3209                                            gen_rtx_LSHIFTRT (mode,
3210                                                              source,
3211                                                              shift))));
3212               emit_constant_insn
3213                 (cond,
3214                  gen_rtx_SET (VOIDmode, target,
3215                               gen_rtx_NOT (mode,
3216                                            gen_rtx_ASHIFT (mode, sub,
3217                                                            shift))));
3218             }
3219           return 2;
3220         }
3221
3222       /* This will never be reached for Thumb2 because orn is a valid
3223          instruction. This is for Thumb1 and the ARM 32 bit cases.
3224
3225          x = y | constant (such that ~constant is a valid constant)
3226          Transform this to
3227          x = ~(~y & ~constant).
3228       */
3229       if (const_ok_for_arm (temp1 = ARM_SIGN_EXTEND (~val)))
3230         {
3231           if (generate)
3232             {
3233               rtx sub = subtargets ? gen_reg_rtx (mode) : target;
3234               emit_constant_insn (cond,
3235                                   gen_rtx_SET (VOIDmode, sub,
3236                                                gen_rtx_NOT (mode, source)));
3237               source = sub;
3238               if (subtargets)
3239                 sub = gen_reg_rtx (mode);
3240               emit_constant_insn (cond,
3241                                   gen_rtx_SET (VOIDmode, sub,
3242                                                gen_rtx_AND (mode, source,
3243                                                             GEN_INT (temp1))));
3244               emit_constant_insn (cond,
3245                                   gen_rtx_SET (VOIDmode, target,
3246                                                gen_rtx_NOT (mode, sub)));
3247             }
3248           return 3;
3249         }
3250       break;
3251
3252     case AND:
3253       /* See if two shifts will do 2 or more insn's worth of work.  */
3254       if (clear_sign_bit_copies >= 16 && clear_sign_bit_copies < 24)
3255         {
3256           HOST_WIDE_INT shift_mask = ((0xffffffff
3257                                        << (32 - clear_sign_bit_copies))
3258                                       & 0xffffffff);
3259
3260           if ((remainder | shift_mask) != 0xffffffff)
3261             {
3262               if (generate)
3263                 {
3264                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3265                   insns = arm_gen_constant (AND, mode, cond,
3266                                             remainder | shift_mask,
3267                                             new_src, source, subtargets, 1);
3268                   source = new_src;
3269                 }
3270               else
3271                 {
3272                   rtx targ = subtargets ? NULL_RTX : target;
3273                   insns = arm_gen_constant (AND, mode, cond,
3274                                             remainder | shift_mask,
3275                                             targ, source, subtargets, 0);
3276                 }
3277             }
3278
3279           if (generate)
3280             {
3281               rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3282               rtx shift = GEN_INT (clear_sign_bit_copies);
3283
3284               emit_insn (gen_ashlsi3 (new_src, source, shift));
3285               emit_insn (gen_lshrsi3 (target, new_src, shift));
3286             }
3287
3288           return insns + 2;
3289         }
3290
3291       if (clear_zero_bit_copies >= 16 && clear_zero_bit_copies < 24)
3292         {
3293           HOST_WIDE_INT shift_mask = (1 << clear_zero_bit_copies) - 1;
3294
3295           if ((remainder | shift_mask) != 0xffffffff)
3296             {
3297               if (generate)
3298                 {
3299                   rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3300
3301                   insns = arm_gen_constant (AND, mode, cond,
3302                                             remainder | shift_mask,
3303                                             new_src, source, subtargets, 1);
3304                   source = new_src;
3305                 }
3306               else
3307                 {
3308                   rtx targ = subtargets ? NULL_RTX : target;
3309
3310                   insns = arm_gen_constant (AND, mode, cond,
3311                                             remainder | shift_mask,
3312                                             targ, source, subtargets, 0);
3313                 }
3314             }
3315
3316           if (generate)
3317             {
3318               rtx new_src = subtargets ? gen_reg_rtx (mode) : target;
3319               rtx shift = GEN_INT (clear_zero_bit_copies);
3320
3321               emit_insn (gen_lshrsi3 (new_src, source, shift));
3322               emit_insn (gen_ashlsi3 (target, new_src, shift));
3323             }
3324
3325           return insns + 2;
3326         }
3327
3328       break;
3329
3330     default:
3331       break;
3332     }
3333
3334   /* Calculate what the instruction sequences would be if we generated it
3335      normally, negated, or inverted.  */
3336   if (code == AND)
3337     /* AND cannot be split into multiple insns, so invert and use BIC.  */
3338     insns = 99;
3339   else
3340     insns = optimal_immediate_sequence (code, remainder, &pos_immediates);
3341
3342   if (can_negate)
3343     neg_insns = optimal_immediate_sequence (code, (-remainder) & 0xffffffff,
3344                                             &neg_immediates);
3345   else
3346     neg_insns = 99;
3347
3348   if (can_invert || final_invert)
3349     inv_insns = optimal_immediate_sequence (code, remainder ^ 0xffffffff,
3350                                             &inv_immediates);
3351   else
3352     inv_insns = 99;
3353
3354   immediates = &pos_immediates;
3355
3356   /* Is the negated immediate sequence more efficient?  */
3357   if (neg_insns < insns && neg_insns <= inv_insns)
3358     {
3359       insns = neg_insns;
3360       immediates = &neg_immediates;
3361     }
3362   else
3363     can_negate = 0;
3364
3365   /* Is the inverted immediate sequence more efficient?
3366      We must allow for an extra NOT instruction for XOR operations, although
3367      there is some chance that the final 'mvn' will get optimized later.  */
3368   if ((inv_insns + 1) < insns || (!final_invert && inv_insns < insns))
3369     {
3370       insns = inv_insns;
3371       immediates = &inv_immediates;
3372     }
3373   else
3374     {
3375       can_invert = 0;
3376       final_invert = 0;
3377     }
3378
3379   /* Now output the chosen sequence as instructions.  */
3380   if (generate)
3381     {
3382       for (i = 0; i < insns; i++)
3383         {
3384           rtx new_src, temp1_rtx;
3385
3386           temp1 = immediates->i[i];
3387
3388           if (code == SET || code == MINUS)
3389             new_src = (subtargets ? gen_reg_rtx (mode) : target);
3390           else if ((final_invert || i < (insns - 1)) && subtargets)
3391             new_src = gen_reg_rtx (mode);
3392           else
3393             new_src = target;
3394
3395           if (can_invert)
3396             temp1 = ~temp1;
3397           else if (can_negate)
3398             temp1 = -temp1;
3399
3400           temp1 = trunc_int_for_mode (temp1, mode);
3401           temp1_rtx = GEN_INT (temp1);
3402
3403           if (code == SET)
3404             ;
3405           else if (code == MINUS)
3406             temp1_rtx = gen_rtx_MINUS (mode, temp1_rtx, source);
3407           else
3408             temp1_rtx = gen_rtx_fmt_ee (code, mode, source, temp1_rtx);
3409
3410           emit_constant_insn (cond,
3411                               gen_rtx_SET (VOIDmode, new_src,
3412                                            temp1_rtx));
3413           source = new_src;
3414
3415           if (code == SET)
3416             {
3417               can_negate = can_invert;
3418               can_invert = 0;
3419               code = PLUS;
3420             }
3421           else if (code == MINUS)
3422             code = PLUS;
3423         }
3424     }
3425
3426   if (final_invert)
3427     {
3428       if (generate)
3429         emit_constant_insn (cond, gen_rtx_SET (VOIDmode, target,
3430                                                gen_rtx_NOT (mode, source)));
3431       insns++;
3432     }
3433
3434   return insns;
3435 }
3436
3437 /* Canonicalize a comparison so that we are more likely to recognize it.
3438    This can be done for a few constant compares, where we can make the
3439    immediate value easier to load.  */
3440
3441 enum rtx_code
3442 arm_canonicalize_comparison (enum rtx_code code, rtx *op0, rtx *op1)
3443 {
3444   enum machine_mode mode;
3445   unsigned HOST_WIDE_INT i, maxval;
3446
3447   mode = GET_MODE (*op0);
3448   if (mode == VOIDmode)
3449     mode = GET_MODE (*op1);
3450
3451   maxval = (((unsigned HOST_WIDE_INT) 1) << (GET_MODE_BITSIZE(mode) - 1)) - 1;
3452
3453   /* For DImode, we have GE/LT/GEU/LTU comparisons.  In ARM mode
3454      we can also use cmp/cmpeq for GTU/LEU.  GT/LE must be either
3455      reversed or (for constant OP1) adjusted to GE/LT.  Similarly
3456      for GTU/LEU in Thumb mode.  */
3457   if (mode == DImode)
3458     {
3459       rtx tem;
3460
3461       /* To keep things simple, always use the Cirrus cfcmp64 if it is
3462          available.  */
3463       if (TARGET_ARM && TARGET_HARD_FLOAT && TARGET_MAVERICK)
3464         return code;
3465
3466       if (code == GT || code == LE
3467           || (!TARGET_ARM && (code == GTU || code == LEU)))
3468         {
3469           /* Missing comparison.  First try to use an available
3470              comparison.  */
3471           if (GET_CODE (*op1) == CONST_INT)
3472             {
3473               i = INTVAL (*op1);
3474               switch (code)
3475                 {
3476                 case GT:
3477                 case LE:
3478                   if (i != maxval
3479                       && arm_const_double_by_immediates (GEN_INT (i + 1)))
3480                     {
3481                       *op1 = GEN_INT (i + 1);
3482                       return code == GT ? GE : LT;
3483                     }
3484                   break;
3485                 case GTU:
3486                 case LEU:
3487                   if (i != ~((unsigned HOST_WIDE_INT) 0)
3488                       && arm_const_double_by_immediates (GEN_INT (i + 1)))
3489                     {
3490                       *op1 = GEN_INT (i + 1);
3491                       return code == GTU ? GEU : LTU;
3492                     }
3493                   break;
3494                 default:
3495                   gcc_unreachable ();
3496                 }
3497             }
3498
3499           /* If that did not work, reverse the condition.  */
3500           tem = *op0;
3501           *op0 = *op1;
3502           *op1 = tem;
3503           return swap_condition (code);
3504         }
3505
3506       return code;
3507     }
3508
3509   /* If *op0 is (zero_extend:SI (subreg:QI (reg:SI) 0)) and comparing
3510      with const0_rtx, change it to (and:SI (reg:SI) (const_int 255)),
3511      to facilitate possible combining with a cmp into 'ands'.  */
3512   if (mode == SImode
3513       && GET_CODE (*op0) == ZERO_EXTEND
3514       && GET_CODE (XEXP (*op0, 0)) == SUBREG
3515       && GET_MODE (XEXP (*op0, 0)) == QImode
3516       && GET_MODE (SUBREG_REG (XEXP (*op0, 0))) == SImode
3517       && subreg_lowpart_p (XEXP (*op0, 0))
3518       && *op1 == const0_rtx)
3519     *op0 = gen_rtx_AND (SImode, SUBREG_REG (XEXP (*op0, 0)),
3520                         GEN_INT (255));
3521
3522   /* Comparisons smaller than DImode.  Only adjust comparisons against
3523      an out-of-range constant.  */
3524   if (GET_CODE (*op1) != CONST_INT
3525       || const_ok_for_arm (INTVAL (*op1))
3526       || const_ok_for_arm (- INTVAL (*op1)))
3527     return code;
3528
3529   i = INTVAL (*op1);
3530
3531   switch (code)
3532     {
3533     case EQ:
3534     case NE:
3535       return code;
3536
3537     case GT:
3538     case LE:
3539       if (i != maxval
3540           && (const_ok_for_arm (i + 1) || const_ok_for_arm (-(i + 1))))
3541         {
3542           *op1 = GEN_INT (i + 1);
3543           return code == GT ? GE : LT;
3544         }
3545       break;
3546
3547     case GE:
3548     case LT:
3549       if (i != ~maxval
3550           && (const_ok_for_arm (i - 1) || const_ok_for_arm (-(i - 1))))
3551         {
3552           *op1 = GEN_INT (i - 1);
3553           return code == GE ? GT : LE;
3554         }
3555       break;
3556
3557     case GTU:
3558     case LEU:
3559       if (i != ~((unsigned HOST_WIDE_INT) 0)
3560           && (const_ok_for_arm (i + 1) || const_ok_for_arm (-(i + 1))))
3561         {
3562           *op1 = GEN_INT (i + 1);
3563           return code == GTU ? GEU : LTU;
3564         }
3565       break;
3566
3567     case GEU:
3568     case LTU:
3569       if (i != 0
3570           && (const_ok_for_arm (i - 1) || const_ok_for_arm (-(i - 1))))
3571         {
3572           *op1 = GEN_INT (i - 1);
3573           return code == GEU ? GTU : LEU;
3574         }
3575       break;
3576
3577     default:
3578       gcc_unreachable ();
3579     }
3580
3581   return code;
3582 }
3583
3584
3585 /* Define how to find the value returned by a function.  */
3586
3587 static rtx
3588 arm_function_value(const_tree type, const_tree func,
3589                    bool outgoing ATTRIBUTE_UNUSED)
3590 {
3591   enum machine_mode mode;
3592   int unsignedp ATTRIBUTE_UNUSED;
3593   rtx r ATTRIBUTE_UNUSED;
3594
3595   mode = TYPE_MODE (type);
3596
3597   if (TARGET_AAPCS_BASED)
3598     return aapcs_allocate_return_reg (mode, type, func);
3599
3600   /* Promote integer types.  */
3601   if (INTEGRAL_TYPE_P (type))
3602     mode = arm_promote_function_mode (type, mode, &unsignedp, func, 1);
3603
3604   /* Promotes small structs returned in a register to full-word size
3605      for big-endian AAPCS.  */
3606   if (arm_return_in_msb (type))
3607     {
3608       HOST_WIDE_INT size = int_size_in_bytes (type);
3609       if (size % UNITS_PER_WORD != 0)
3610         {
3611           size += UNITS_PER_WORD - size % UNITS_PER_WORD;
3612           mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
3613         }
3614     }
3615
3616   return arm_libcall_value_1 (mode);
3617 }
3618
3619 static int
3620 libcall_eq (const void *p1, const void *p2)
3621 {
3622   return rtx_equal_p ((const_rtx) p1, (const_rtx) p2);
3623 }
3624
3625 static hashval_t
3626 libcall_hash (const void *p1)
3627 {
3628   return hash_rtx ((const_rtx) p1, VOIDmode, NULL, NULL, FALSE);
3629 }
3630
3631 static void
3632 add_libcall (htab_t htab, rtx libcall)
3633 {
3634   *htab_find_slot (htab, libcall, INSERT) = libcall;
3635 }
3636
3637 static bool
3638 arm_libcall_uses_aapcs_base (const_rtx libcall)
3639 {
3640   static bool init_done = false;
3641   static htab_t libcall_htab;
3642
3643   if (!init_done)
3644     {
3645       init_done = true;
3646
3647       libcall_htab = htab_create (31, libcall_hash, libcall_eq,
3648                                   NULL);
3649       add_libcall (libcall_htab,
3650                    convert_optab_libfunc (sfloat_optab, SFmode, SImode));
3651       add_libcall (libcall_htab,
3652                    convert_optab_libfunc (sfloat_optab, DFmode, SImode));
3653       add_libcall (libcall_htab,
3654                    convert_optab_libfunc (sfloat_optab, SFmode, DImode));
3655       add_libcall (libcall_htab,
3656                    convert_optab_libfunc (sfloat_optab, DFmode, DImode));
3657
3658       add_libcall (libcall_htab,
3659                    convert_optab_libfunc (ufloat_optab, SFmode, SImode));
3660       add_libcall (libcall_htab,
3661                    convert_optab_libfunc (ufloat_optab, DFmode, SImode));
3662       add_libcall (libcall_htab,
3663                    convert_optab_libfunc (ufloat_optab, SFmode, DImode));
3664       add_libcall (libcall_htab,
3665                    convert_optab_libfunc (ufloat_optab, DFmode, DImode));
3666
3667       add_libcall (libcall_htab,
3668                    convert_optab_libfunc (sext_optab, SFmode, HFmode));
3669       add_libcall (libcall_htab,
3670                    convert_optab_libfunc (trunc_optab, HFmode, SFmode));
3671       add_libcall (libcall_htab,
3672                    convert_optab_libfunc (sfix_optab, SImode, DFmode));
3673       add_libcall (libcall_htab,
3674                    convert_optab_libfunc (ufix_optab, SImode, DFmode));
3675       add_libcall (libcall_htab,
3676                    convert_optab_libfunc (sfix_optab, DImode, DFmode));
3677       add_libcall (libcall_htab,
3678                    convert_optab_libfunc (ufix_optab, DImode, DFmode));
3679       add_libcall (libcall_htab,
3680                    convert_optab_libfunc (sfix_optab, DImode, SFmode));
3681       add_libcall (libcall_htab,
3682                    convert_optab_libfunc (ufix_optab, DImode, SFmode));
3683
3684       /* Values from double-precision helper functions are returned in core
3685          registers if the selected core only supports single-precision
3686          arithmetic, even if we are using the hard-float ABI.  The same is
3687          true for single-precision helpers, but we will never be using the
3688          hard-float ABI on a CPU which doesn't support single-precision
3689          operations in hardware.  */
3690       add_libcall (libcall_htab, optab_libfunc (add_optab, DFmode));
3691       add_libcall (libcall_htab, optab_libfunc (sdiv_optab, DFmode));
3692       add_libcall (libcall_htab, optab_libfunc (smul_optab, DFmode));
3693       add_libcall (libcall_htab, optab_libfunc (neg_optab, DFmode));
3694       add_libcall (libcall_htab, optab_libfunc (sub_optab, DFmode));
3695       add_libcall (libcall_htab, optab_libfunc (eq_optab, DFmode));
3696       add_libcall (libcall_htab, optab_libfunc (lt_optab, DFmode));
3697       add_libcall (libcall_htab, optab_libfunc (le_optab, DFmode));
3698       add_libcall (libcall_htab, optab_libfunc (ge_optab, DFmode));
3699       add_libcall (libcall_htab, optab_libfunc (gt_optab, DFmode));
3700       add_libcall (libcall_htab, optab_libfunc (unord_optab, DFmode));
3701       add_libcall (libcall_htab, convert_optab_libfunc (sext_optab, DFmode,
3702                                                         SFmode));
3703       add_libcall (libcall_htab, convert_optab_libfunc (trunc_optab, SFmode,
3704                                                         DFmode));
3705     }
3706
3707   return libcall && htab_find (libcall_htab, libcall) != NULL;
3708 }
3709
3710 static rtx
3711 arm_libcall_value_1 (enum machine_mode mode)
3712 {
3713   if (TARGET_AAPCS_BASED)
3714     return aapcs_libcall_value (mode);
3715   else if (TARGET_32BIT
3716            && TARGET_HARD_FLOAT_ABI
3717            && TARGET_FPA
3718            && GET_MODE_CLASS (mode) == MODE_FLOAT)
3719     return gen_rtx_REG (mode, FIRST_FPA_REGNUM);
3720   else if (TARGET_32BIT
3721            && TARGET_HARD_FLOAT_ABI
3722            && TARGET_MAVERICK
3723            && GET_MODE_CLASS (mode) == MODE_FLOAT)
3724     return gen_rtx_REG (mode, FIRST_CIRRUS_FP_REGNUM);
3725   else if (TARGET_IWMMXT_ABI
3726            && arm_vector_mode_supported_p (mode))
3727     return gen_rtx_REG (mode, FIRST_IWMMXT_REGNUM);
3728   else
3729     return gen_rtx_REG (mode, ARG_REGISTER (1));
3730 }
3731
3732 /* Define how to find the value returned by a library function
3733    assuming the value has mode MODE.  */
3734
3735 static rtx
3736 arm_libcall_value (enum machine_mode mode, const_rtx libcall)
3737 {
3738   if (TARGET_AAPCS_BASED && arm_pcs_default != ARM_PCS_AAPCS
3739       && GET_MODE_CLASS (mode) == MODE_FLOAT)
3740     {
3741       /* The following libcalls return their result in integer registers,
3742          even though they return a floating point value.  */
3743       if (arm_libcall_uses_aapcs_base (libcall))
3744         return gen_rtx_REG (mode, ARG_REGISTER(1));
3745
3746     }
3747
3748   return arm_libcall_value_1 (mode);
3749 }
3750
3751 /* Implement TARGET_FUNCTION_VALUE_REGNO_P.  */
3752
3753 static bool
3754 arm_function_value_regno_p (const unsigned int regno)
3755 {
3756   if (regno == ARG_REGISTER (1)
3757       || (TARGET_32BIT
3758           && TARGET_AAPCS_BASED
3759           && TARGET_VFP
3760           && TARGET_HARD_FLOAT
3761           && regno == FIRST_VFP_REGNUM)
3762       || (TARGET_32BIT
3763           && TARGET_HARD_FLOAT_ABI
3764           && TARGET_MAVERICK
3765           && regno == FIRST_CIRRUS_FP_REGNUM)
3766       || (TARGET_IWMMXT_ABI
3767           && regno == FIRST_IWMMXT_REGNUM)
3768       || (TARGET_32BIT
3769           && TARGET_HARD_FLOAT_ABI
3770           && TARGET_FPA
3771           && regno == FIRST_FPA_REGNUM))
3772     return true;
3773
3774   return false;
3775 }
3776
3777 /* Determine the amount of memory needed to store the possible return
3778    registers of an untyped call.  */
3779 int
3780 arm_apply_result_size (void)
3781 {
3782   int size = 16;
3783
3784   if (TARGET_32BIT)
3785     {
3786       if (TARGET_HARD_FLOAT_ABI)
3787         {
3788           if (TARGET_VFP)
3789             size += 32;
3790           if (TARGET_FPA)
3791             size += 12;
3792           if (TARGET_MAVERICK)
3793             size += 8;
3794         }
3795       if (TARGET_IWMMXT_ABI)
3796         size += 8;
3797     }
3798
3799   return size;
3800 }
3801
3802 /* Decide whether TYPE should be returned in memory (true)
3803    or in a register (false).  FNTYPE is the type of the function making
3804    the call.  */
3805 static bool
3806 arm_return_in_memory (const_tree type, const_tree fntype)
3807 {
3808   HOST_WIDE_INT size;
3809
3810   size = int_size_in_bytes (type);  /* Negative if not fixed size.  */
3811
3812   if (TARGET_AAPCS_BASED)
3813     {
3814       /* Simple, non-aggregate types (ie not including vectors and
3815          complex) are always returned in a register (or registers).
3816          We don't care about which register here, so we can short-cut
3817          some of the detail.  */
3818       if (!AGGREGATE_TYPE_P (type)
3819           && TREE_CODE (type) != VECTOR_TYPE
3820           && TREE_CODE (type) != COMPLEX_TYPE)
3821         return false;
3822
3823       /* Any return value that is no larger than one word can be
3824          returned in r0.  */
3825       if (((unsigned HOST_WIDE_INT) size) <= UNITS_PER_WORD)
3826         return false;
3827
3828       /* Check any available co-processors to see if they accept the
3829          type as a register candidate (VFP, for example, can return
3830          some aggregates in consecutive registers).  These aren't
3831          available if the call is variadic.  */
3832       if (aapcs_select_return_coproc (type, fntype) >= 0)
3833         return false;
3834
3835       /* Vector values should be returned using ARM registers, not
3836          memory (unless they're over 16 bytes, which will break since
3837          we only have four call-clobbered registers to play with).  */
3838       if (TREE_CODE (type) == VECTOR_TYPE)
3839         return (size < 0 || size > (4 * UNITS_PER_WORD));
3840
3841       /* The rest go in memory.  */
3842       return true;
3843     }
3844
3845   if (TREE_CODE (type) == VECTOR_TYPE)
3846     return (size < 0 || size > (4 * UNITS_PER_WORD));
3847
3848   if (!AGGREGATE_TYPE_P (type) &&
3849       (TREE_CODE (type) != VECTOR_TYPE))
3850     /* All simple types are returned in registers.  */
3851     return false;
3852
3853   if (arm_abi != ARM_ABI_APCS)
3854     {
3855       /* ATPCS and later return aggregate types in memory only if they are
3856          larger than a word (or are variable size).  */
3857       return (size < 0 || size > UNITS_PER_WORD);
3858     }
3859
3860   /* For the arm-wince targets we choose to be compatible with Microsoft's
3861      ARM and Thumb compilers, which always return aggregates in memory.  */
3862 #ifndef ARM_WINCE
3863   /* All structures/unions bigger than one word are returned in memory.
3864      Also catch the case where int_size_in_bytes returns -1.  In this case
3865      the aggregate is either huge or of variable size, and in either case
3866      we will want to return it via memory and not in a register.  */
3867   if (size < 0 || size > UNITS_PER_WORD)
3868     return true;
3869
3870   if (TREE_CODE (type) == RECORD_TYPE)
3871     {
3872       tree field;
3873
3874       /* For a struct the APCS says that we only return in a register
3875          if the type is 'integer like' and every addressable element
3876          has an offset of zero.  For practical purposes this means
3877          that the structure can have at most one non bit-field element
3878          and that this element must be the first one in the structure.  */
3879
3880       /* Find the first field, ignoring non FIELD_DECL things which will
3881          have been created by C++.  */
3882       for (field = TYPE_FIELDS (type);
3883            field && TREE_CODE (field) != FIELD_DECL;
3884            field = DECL_CHAIN (field))
3885         continue;
3886
3887       if (field == NULL)
3888         return false; /* An empty structure.  Allowed by an extension to ANSI C.  */
3889
3890       /* Check that the first field is valid for returning in a register.  */
3891
3892       /* ... Floats are not allowed */
3893       if (FLOAT_TYPE_P (TREE_TYPE (field)))
3894         return true;
3895
3896       /* ... Aggregates that are not themselves valid for returning in
3897          a register are not allowed.  */
3898       if (arm_return_in_memory (TREE_TYPE (field), NULL_TREE))
3899         return true;
3900
3901       /* Now check the remaining fields, if any.  Only bitfields are allowed,
3902          since they are not addressable.  */
3903       for (field = DECL_CHAIN (field);
3904            field;
3905            field = DECL_CHAIN (field))
3906         {
3907           if (TREE_CODE (field) != FIELD_DECL)
3908             continue;
3909
3910           if (!DECL_BIT_FIELD_TYPE (field))
3911             return true;
3912         }
3913
3914       return false;
3915     }
3916
3917   if (TREE_CODE (type) == UNION_TYPE)
3918     {
3919       tree field;
3920
3921       /* Unions can be returned in registers if every element is
3922          integral, or can be returned in an integer register.  */
3923       for (field = TYPE_FIELDS (type);
3924            field;
3925            field = DECL_CHAIN (field))
3926         {
3927           if (TREE_CODE (field) != FIELD_DECL)
3928             continue;
3929
3930           if (FLOAT_TYPE_P (TREE_TYPE (field)))
3931             return true;
3932
3933           if (arm_return_in_memory (TREE_TYPE (field), NULL_TREE))
3934             return true;
3935         }
3936
3937       return false;
3938     }
3939 #endif /* not ARM_WINCE */
3940
3941   /* Return all other types in memory.  */
3942   return true;
3943 }
3944
3945 /* Indicate whether or not words of a double are in big-endian order.  */
3946
3947 int
3948 arm_float_words_big_endian (void)
3949 {
3950   if (TARGET_MAVERICK)
3951     return 0;
3952
3953   /* For FPA, float words are always big-endian.  For VFP, floats words
3954      follow the memory system mode.  */
3955
3956   if (TARGET_FPA)
3957     {
3958       return 1;
3959     }
3960
3961   if (TARGET_VFP)
3962     return (TARGET_BIG_END ? 1 : 0);
3963
3964   return 1;
3965 }