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