* gcc.dg/torture/mips-hilo-2.c: Provide dummy __mips16 version.
[gcc/gcc.git] / gcc / config / rs6000 / rs6000.c
1 /* Subroutines used for code generation on IBM RS/6000.
2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 
3    2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
4    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
5
6    This file is part of GCC.
7
8    GCC is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published
10    by the Free Software Foundation; either version 2, or (at your
11    option) any later version.
12
13    GCC is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GCC; see the file COPYING.  If not, write to the
20    Free Software Foundation, 59 Temple Place - Suite 330, Boston,
21    MA 02111-1307, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "insn-attr.h"
34 #include "flags.h"
35 #include "recog.h"
36 #include "obstack.h"
37 #include "tree.h"
38 #include "expr.h"
39 #include "optabs.h"
40 #include "except.h"
41 #include "function.h"
42 #include "output.h"
43 #include "basic-block.h"
44 #include "integrate.h"
45 #include "toplev.h"
46 #include "ggc.h"
47 #include "hashtab.h"
48 #include "tm_p.h"
49 #include "target.h"
50 #include "target-def.h"
51 #include "langhooks.h"
52 #include "reload.h"
53 #include "cfglayout.h"
54 #include "sched-int.h"
55 #if TARGET_XCOFF
56 #include "xcoffout.h"  /* get declarations of xcoff_*_section_name */
57 #endif
58
59 #ifndef TARGET_NO_PROTOTYPE
60 #define TARGET_NO_PROTOTYPE 0
61 #endif
62
63 #define EASY_VECTOR_15(n) ((n) >= -16 && (n) <= 15)
64 #define EASY_VECTOR_15_ADD_SELF(n) ((n) >= 0x10 && (n) <= 0x1e \
65                                           && !((n) & 1))
66
67 #define min(A,B)        ((A) < (B) ? (A) : (B))
68 #define max(A,B)        ((A) > (B) ? (A) : (B))
69
70 /* Structure used to define the rs6000 stack */
71 typedef struct rs6000_stack {
72   int first_gp_reg_save;        /* first callee saved GP register used */
73   int first_fp_reg_save;        /* first callee saved FP register used */
74   int first_altivec_reg_save;   /* first callee saved AltiVec register used */
75   int lr_save_p;                /* true if the link reg needs to be saved */
76   int cr_save_p;                /* true if the CR reg needs to be saved */
77   unsigned int vrsave_mask;     /* mask of vec registers to save */
78   int toc_save_p;               /* true if the TOC needs to be saved */
79   int push_p;                   /* true if we need to allocate stack space */
80   int calls_p;                  /* true if the function makes any calls */
81   enum rs6000_abi abi;          /* which ABI to use */
82   int gp_save_offset;           /* offset to save GP regs from initial SP */
83   int fp_save_offset;           /* offset to save FP regs from initial SP */
84   int altivec_save_offset;      /* offset to save AltiVec regs from initial SP */
85   int lr_save_offset;           /* offset to save LR from initial SP */
86   int cr_save_offset;           /* offset to save CR from initial SP */
87   int vrsave_save_offset;       /* offset to save VRSAVE from initial SP */
88   int spe_gp_save_offset;       /* offset to save spe 64-bit gprs  */
89   int toc_save_offset;          /* offset to save the TOC pointer */
90   int varargs_save_offset;      /* offset to save the varargs registers */
91   int ehrd_offset;              /* offset to EH return data */
92   int reg_size;                 /* register size (4 or 8) */
93   int varargs_size;             /* size to hold V.4 args passed in regs */
94   HOST_WIDE_INT vars_size;      /* variable save area size */
95   int parm_size;                /* outgoing parameter size */
96   int save_size;                /* save area size */
97   int fixed_size;               /* fixed size of stack frame */
98   int gp_size;                  /* size of saved GP registers */
99   int fp_size;                  /* size of saved FP registers */
100   int altivec_size;             /* size of saved AltiVec registers */
101   int cr_size;                  /* size to hold CR if not in save_size */
102   int lr_size;                  /* size to hold LR if not in save_size */
103   int vrsave_size;              /* size to hold VRSAVE if not in save_size */
104   int altivec_padding_size;     /* size of altivec alignment padding if
105                                    not in save_size */
106   int spe_gp_size;              /* size of 64-bit GPR save size for SPE */
107   int spe_padding_size;
108   int toc_size;                 /* size to hold TOC if not in save_size */
109   HOST_WIDE_INT total_size;     /* total bytes allocated for stack */
110   int spe_64bit_regs_used;
111 } rs6000_stack_t;
112
113 /* Target cpu type */
114
115 enum processor_type rs6000_cpu;
116 struct rs6000_cpu_select rs6000_select[3] =
117 {
118   /* switch             name,                   tune    arch */
119   { (const char *)0,    "--with-cpu=",          1,      1 },
120   { (const char *)0,    "-mcpu=",               1,      1 },
121   { (const char *)0,    "-mtune=",              1,      0 },
122 };
123
124 /* Always emit branch hint bits.  */
125 static GTY(()) bool rs6000_always_hint;
126
127 /* Schedule instructions for group formation.  */
128 static GTY(()) bool rs6000_sched_groups;
129
130 /* Support adjust_priority scheduler hook 
131    and -mprioritize-restricted-insns= option.  */
132 const char *rs6000_sched_restricted_insns_priority_str;
133 int rs6000_sched_restricted_insns_priority;
134
135 /* Support for -msched-costly-dep option.  */
136 const char *rs6000_sched_costly_dep_str;
137 enum rs6000_dependence_cost rs6000_sched_costly_dep;
138
139 /* Support for -minsert-sched-nops option.  */
140 const char *rs6000_sched_insert_nops_str;
141 enum rs6000_nop_insertion rs6000_sched_insert_nops;
142
143 /* Size of long double */
144 const char *rs6000_long_double_size_string;
145 int rs6000_long_double_type_size;
146
147 /* Whether -mabi=altivec has appeared */
148 int rs6000_altivec_abi;
149
150 /* Whether VRSAVE instructions should be generated.  */
151 int rs6000_altivec_vrsave;
152
153 /* String from -mvrsave= option.  */
154 const char *rs6000_altivec_vrsave_string;
155
156 /* Nonzero if we want SPE ABI extensions.  */
157 int rs6000_spe_abi;
158
159 /* Whether isel instructions should be generated.  */
160 int rs6000_isel;
161
162 /* Whether SPE simd instructions should be generated.  */
163 int rs6000_spe;
164
165 /* Nonzero if floating point operations are done in the GPRs.  */
166 int rs6000_float_gprs = 0;
167
168 /* String from -mfloat-gprs=.  */
169 const char *rs6000_float_gprs_string;
170
171 /* String from -misel=.  */
172 const char *rs6000_isel_string;
173
174 /* String from -mspe=.  */
175 const char *rs6000_spe_string;
176
177 /* Set to nonzero once AIX common-mode calls have been defined.  */
178 static GTY(()) int common_mode_defined;
179
180 /* Save information from a "cmpxx" operation until the branch or scc is
181    emitted.  */
182 rtx rs6000_compare_op0, rs6000_compare_op1;
183 int rs6000_compare_fp_p;
184
185 /* Label number of label created for -mrelocatable, to call to so we can
186    get the address of the GOT section */
187 int rs6000_pic_labelno;
188
189 #ifdef USING_ELFOS_H
190 /* Which abi to adhere to */
191 const char *rs6000_abi_name;
192
193 /* Semantics of the small data area */
194 enum rs6000_sdata_type rs6000_sdata = SDATA_DATA;
195
196 /* Which small data model to use */
197 const char *rs6000_sdata_name = (char *)0;
198
199 /* Counter for labels which are to be placed in .fixup.  */
200 int fixuplabelno = 0;
201 #endif
202
203 /* Bit size of immediate TLS offsets and string from which it is decoded.  */
204 int rs6000_tls_size = 32;
205 const char *rs6000_tls_size_string;
206
207 /* ABI enumeration available for subtarget to use.  */
208 enum rs6000_abi rs6000_current_abi;
209
210 /* ABI string from -mabi= option.  */
211 const char *rs6000_abi_string;
212
213 /* Debug flags */
214 const char *rs6000_debug_name;
215 int rs6000_debug_stack;         /* debug stack applications */
216 int rs6000_debug_arg;           /* debug argument handling */
217
218 /* Opaque types.  */
219 static GTY(()) tree opaque_V2SI_type_node;
220 static GTY(()) tree opaque_V2SF_type_node;
221 static GTY(()) tree opaque_p_V2SI_type_node;
222 static GTY(()) tree V16QI_type_node;
223 static GTY(()) tree V2SI_type_node;
224 static GTY(()) tree V2SF_type_node;
225 static GTY(()) tree V4HI_type_node;
226 static GTY(()) tree V4SI_type_node;
227 static GTY(()) tree V4SF_type_node;
228 static GTY(()) tree V8HI_type_node;
229 static GTY(()) tree unsigned_V16QI_type_node;
230 static GTY(()) tree unsigned_V8HI_type_node;
231 static GTY(()) tree unsigned_V4SI_type_node;
232 static GTY(()) tree bool_char_type_node;        /* __bool char */
233 static GTY(()) tree bool_short_type_node;       /* __bool short */
234 static GTY(()) tree bool_int_type_node;         /* __bool int */
235 static GTY(()) tree pixel_type_node;            /* __pixel */
236 static GTY(()) tree bool_V16QI_type_node;       /* __vector __bool char */
237 static GTY(()) tree bool_V8HI_type_node;        /* __vector __bool short */
238 static GTY(()) tree bool_V4SI_type_node;        /* __vector __bool int */
239 static GTY(()) tree pixel_V8HI_type_node;       /* __vector __pixel */
240
241 int rs6000_warn_altivec_long = 1;               /* On by default. */
242 const char *rs6000_warn_altivec_long_switch;
243
244 const char *rs6000_traceback_name;
245 static enum {
246   traceback_default = 0,
247   traceback_none,
248   traceback_part,
249   traceback_full
250 } rs6000_traceback;
251
252 /* Flag to say the TOC is initialized */
253 int toc_initialized;
254 char toc_label_name[10];
255
256 /* Alias set for saves and restores from the rs6000 stack.  */
257 static GTY(()) int rs6000_sr_alias_set;
258
259 /* Call distance, overridden by -mlongcall and #pragma longcall(1).
260    The only place that looks at this is rs6000_set_default_type_attributes;
261    everywhere else should rely on the presence or absence of a longcall
262    attribute on the function declaration.  */
263 int rs6000_default_long_calls;
264 const char *rs6000_longcall_switch;
265
266 /* Control alignment for fields within structures.  */
267 /* String from -malign-XXXXX.  */
268 const char *rs6000_alignment_string;
269 int rs6000_alignment_flags;
270
271 struct builtin_description
272 {
273   /* mask is not const because we're going to alter it below.  This
274      nonsense will go away when we rewrite the -march infrastructure
275      to give us more target flag bits.  */
276   unsigned int mask;
277   const enum insn_code icode;
278   const char *const name;
279   const enum rs6000_builtins code;
280 };
281
282 static bool rs6000_function_ok_for_sibcall (tree, tree);
283 static int num_insns_constant_wide (HOST_WIDE_INT);
284 static void validate_condition_mode (enum rtx_code, enum machine_mode);
285 static rtx rs6000_generate_compare (enum rtx_code);
286 static void rs6000_maybe_dead (rtx);
287 static void rs6000_emit_stack_tie (void);
288 static void rs6000_frame_related (rtx, rtx, HOST_WIDE_INT, rtx, rtx);
289 static rtx spe_synthesize_frame_save (rtx);
290 static bool spe_func_has_64bit_regs_p (void);
291 static void emit_frame_save (rtx, rtx, enum machine_mode, unsigned int,
292                              int, HOST_WIDE_INT);
293 static rtx gen_frame_mem_offset (enum machine_mode, rtx, int);
294 static void rs6000_emit_allocate_stack (HOST_WIDE_INT, int);
295 static unsigned rs6000_hash_constant (rtx);
296 static unsigned toc_hash_function (const void *);
297 static int toc_hash_eq (const void *, const void *);
298 static int constant_pool_expr_1 (rtx, int *, int *);
299 static bool constant_pool_expr_p (rtx);
300 static bool toc_relative_expr_p (rtx);
301 static bool legitimate_small_data_p (enum machine_mode, rtx);
302 static bool legitimate_offset_address_p (enum machine_mode, rtx, int);
303 static bool legitimate_indexed_address_p (rtx, int);
304 static bool legitimate_indirect_address_p (rtx, int);
305 static bool macho_lo_sum_memory_operand (rtx x, enum machine_mode mode);
306 static bool legitimate_lo_sum_address_p (enum machine_mode, rtx, int);
307 static struct machine_function * rs6000_init_machine_status (void);
308 static bool rs6000_assemble_integer (rtx, unsigned int, int);
309 #ifdef HAVE_GAS_HIDDEN
310 static void rs6000_assemble_visibility (tree, int);
311 #endif
312 static int rs6000_ra_ever_killed (void);
313 static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
314 static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
315 static const char *rs6000_mangle_fundamental_type (tree);
316 extern const struct attribute_spec rs6000_attribute_table[];
317 static void rs6000_set_default_type_attributes (tree);
318 static void rs6000_output_function_prologue (FILE *, HOST_WIDE_INT);
319 static void rs6000_output_function_epilogue (FILE *, HOST_WIDE_INT);
320 static void rs6000_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
321                                     tree);
322 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
323 static bool rs6000_return_in_memory (tree, tree);
324 static void rs6000_file_start (void);
325 #if TARGET_ELF
326 static unsigned int rs6000_elf_section_type_flags (tree, const char *, int);
327 static void rs6000_elf_asm_out_constructor (rtx, int);
328 static void rs6000_elf_asm_out_destructor (rtx, int);
329 static void rs6000_elf_select_section (tree, int, unsigned HOST_WIDE_INT);
330 static void rs6000_elf_unique_section (tree, int);
331 static void rs6000_elf_select_rtx_section (enum machine_mode, rtx,
332                                            unsigned HOST_WIDE_INT);
333 static void rs6000_elf_encode_section_info (tree, rtx, int)
334      ATTRIBUTE_UNUSED;
335 static bool rs6000_elf_in_small_data_p (tree);
336 #endif
337 #if TARGET_XCOFF
338 static void rs6000_xcoff_asm_globalize_label (FILE *, const char *);
339 static void rs6000_xcoff_asm_named_section (const char *, unsigned int);
340 static void rs6000_xcoff_select_section (tree, int, unsigned HOST_WIDE_INT);
341 static void rs6000_xcoff_unique_section (tree, int);
342 static void rs6000_xcoff_select_rtx_section (enum machine_mode, rtx,
343                                              unsigned HOST_WIDE_INT);
344 static const char * rs6000_xcoff_strip_name_encoding (const char *);
345 static unsigned int rs6000_xcoff_section_type_flags (tree, const char *, int);
346 static void rs6000_xcoff_file_start (void);
347 static void rs6000_xcoff_file_end (void);
348 #endif
349 #if TARGET_MACHO
350 static bool rs6000_binds_local_p (tree);
351 #endif
352 static int rs6000_use_dfa_pipeline_interface (void);
353 static int rs6000_variable_issue (FILE *, int, rtx, int);
354 static bool rs6000_rtx_costs (rtx, int, int, int *);
355 static int rs6000_adjust_cost (rtx, rtx, rtx, int);
356 static bool is_microcoded_insn (rtx);
357 static int is_dispatch_slot_restricted (rtx);
358 static bool is_cracked_insn (rtx);
359 static bool is_branch_slot_insn (rtx);
360 static int rs6000_adjust_priority (rtx, int);
361 static int rs6000_issue_rate (void);
362 static bool rs6000_is_costly_dependence (rtx, rtx, rtx, int, int);
363 static rtx get_next_active_insn (rtx, rtx);
364 static bool insn_terminates_group_p (rtx , enum group_termination);
365 static bool is_costly_group (rtx *, rtx);
366 static int force_new_group (int, FILE *, rtx *, rtx, bool *, int, int *);
367 static int redefine_groups (FILE *, int, rtx, rtx);
368 static int pad_groups (FILE *, int, rtx, rtx);
369 static void rs6000_sched_finish (FILE *, int);
370 static int rs6000_use_sched_lookahead (void);
371
372 static void rs6000_init_builtins (void);
373 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
374 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
375 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
376 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
377 static void altivec_init_builtins (void);
378 static void rs6000_common_init_builtins (void);
379 static void rs6000_init_libfuncs (void);
380
381 static void enable_mask_for_builtins (struct builtin_description *, int,
382                                       enum rs6000_builtins,
383                                       enum rs6000_builtins);
384 static void spe_init_builtins (void);
385 static rtx spe_expand_builtin (tree, rtx, bool *);
386 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
387 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
388 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
389 static rs6000_stack_t *rs6000_stack_info (void);
390 static void debug_stack_info (rs6000_stack_t *);
391
392 static rtx altivec_expand_builtin (tree, rtx, bool *);
393 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
394 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
395 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
396 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
397 static rtx altivec_expand_predicate_builtin (enum insn_code, 
398                                             const char *, tree, rtx);
399 static rtx altivec_expand_lv_builtin (enum insn_code, tree, rtx);
400 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
401 static void rs6000_parse_abi_options (void);
402 static void rs6000_parse_alignment_option (void);
403 static void rs6000_parse_tls_size_option (void);
404 static void rs6000_parse_yes_no_option (const char *, const char *, int *);
405 static int first_altivec_reg_to_save (void);
406 static unsigned int compute_vrsave_mask (void);
407 static void is_altivec_return_reg (rtx, void *);
408 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
409 int easy_vector_constant (rtx, enum machine_mode);
410 static int easy_vector_same (rtx, enum machine_mode);
411 static int easy_vector_splat_const (int, enum machine_mode);
412 static bool is_ev64_opaque_type (tree);
413 static rtx rs6000_dwarf_register_span (rtx);
414 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
415 static rtx rs6000_tls_get_addr (void);
416 static rtx rs6000_got_sym (void);
417 static inline int rs6000_tls_symbol_ref_1 (rtx *, void *);
418 static const char *rs6000_get_some_local_dynamic_name (void);
419 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
420 static rtx rs6000_complex_function_value (enum machine_mode);
421 static rtx rs6000_spe_function_arg (CUMULATIVE_ARGS *,
422                                     enum machine_mode, tree);
423 static rtx rs6000_mixed_function_arg (CUMULATIVE_ARGS *,
424                                       enum machine_mode, tree, int);
425 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
426 static void setup_incoming_varargs (CUMULATIVE_ARGS *,
427                                     enum machine_mode, tree,
428                                     int *, int);
429 #if TARGET_MACHO
430 static void macho_branch_islands (void);
431 static void add_compiler_branch_island (tree, tree, int);
432 static int no_previous_def (tree function_name);
433 static tree get_prev_label (tree function_name);
434 #endif
435
436 static tree rs6000_build_builtin_va_list (void);
437
438 /* Hash table stuff for keeping track of TOC entries.  */
439
440 struct toc_hash_struct GTY(())
441 {
442   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
443      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
444   rtx key;
445   enum machine_mode key_mode;
446   int labelno;
447 };
448
449 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
450 \f
451 /* Default register names.  */
452 char rs6000_reg_names[][8] =
453 {
454       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
455       "8",  "9", "10", "11", "12", "13", "14", "15",
456      "16", "17", "18", "19", "20", "21", "22", "23",
457      "24", "25", "26", "27", "28", "29", "30", "31",
458       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
459       "8",  "9", "10", "11", "12", "13", "14", "15",
460      "16", "17", "18", "19", "20", "21", "22", "23",
461      "24", "25", "26", "27", "28", "29", "30", "31",
462      "mq", "lr", "ctr","ap",
463       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
464       "xer",
465       /* AltiVec registers.  */
466       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
467       "8",  "9",  "10", "11", "12", "13", "14", "15",
468       "16", "17", "18", "19", "20", "21", "22", "23",
469       "24", "25", "26", "27", "28", "29", "30", "31",
470       "vrsave", "vscr",
471       /* SPE registers.  */
472       "spe_acc", "spefscr"
473 };
474
475 #ifdef TARGET_REGNAMES
476 static const char alt_reg_names[][8] =
477 {
478    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
479    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
480   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
481   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
482    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
483    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
484   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
485   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
486     "mq",    "lr",  "ctr",   "ap",
487   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
488    "xer",
489   /* AltiVec registers.  */
490    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
491    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
492   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
493   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
494   "vrsave", "vscr",
495   /* SPE registers.  */
496   "spe_acc", "spefscr"
497 };
498 #endif
499 \f
500 #ifndef MASK_STRICT_ALIGN
501 #define MASK_STRICT_ALIGN 0
502 #endif
503 #ifndef TARGET_PROFILE_KERNEL
504 #define TARGET_PROFILE_KERNEL 0
505 #endif
506
507 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
508 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
509
510 /* Return 1 for a symbol ref for a thread-local storage symbol.  */
511 #define RS6000_SYMBOL_REF_TLS_P(RTX) \
512   (GET_CODE (RTX) == SYMBOL_REF && SYMBOL_REF_TLS_MODEL (RTX) != 0)
513 \f
514 /* Initialize the GCC target structure.  */
515 #undef TARGET_ATTRIBUTE_TABLE
516 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
517 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
518 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
519
520 #undef TARGET_ASM_ALIGNED_DI_OP
521 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
522
523 /* Default unaligned ops are only provided for ELF.  Find the ops needed
524    for non-ELF systems.  */
525 #ifndef OBJECT_FORMAT_ELF
526 #if TARGET_XCOFF
527 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
528    64-bit targets.  */
529 #undef TARGET_ASM_UNALIGNED_HI_OP
530 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
531 #undef TARGET_ASM_UNALIGNED_SI_OP
532 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
533 #undef TARGET_ASM_UNALIGNED_DI_OP
534 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
535 #else
536 /* For Darwin.  */
537 #undef TARGET_ASM_UNALIGNED_HI_OP
538 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
539 #undef TARGET_ASM_UNALIGNED_SI_OP
540 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
541 #endif
542 #endif
543
544 /* This hook deals with fixups for relocatable code and DI-mode objects
545    in 64-bit code.  */
546 #undef TARGET_ASM_INTEGER
547 #define TARGET_ASM_INTEGER rs6000_assemble_integer
548
549 #ifdef HAVE_GAS_HIDDEN
550 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
551 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
552 #endif
553
554 #undef TARGET_HAVE_TLS
555 #define TARGET_HAVE_TLS HAVE_AS_TLS
556
557 #undef TARGET_CANNOT_FORCE_CONST_MEM
558 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_tls_referenced_p
559
560 #undef TARGET_ASM_FUNCTION_PROLOGUE
561 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
562 #undef TARGET_ASM_FUNCTION_EPILOGUE
563 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
564
565 #undef  TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE 
566 #define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE rs6000_use_dfa_pipeline_interface
567 #undef  TARGET_SCHED_VARIABLE_ISSUE
568 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
569
570 #undef TARGET_SCHED_ISSUE_RATE
571 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
572 #undef TARGET_SCHED_ADJUST_COST
573 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
574 #undef TARGET_SCHED_ADJUST_PRIORITY
575 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
576 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE      
577 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
578 #undef TARGET_SCHED_FINISH
579 #define TARGET_SCHED_FINISH rs6000_sched_finish
580
581 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
582 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
583
584 #undef TARGET_INIT_BUILTINS
585 #define TARGET_INIT_BUILTINS rs6000_init_builtins
586
587 #undef TARGET_EXPAND_BUILTIN
588 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
589
590 #undef TARGET_MANGLE_FUNDAMENTAL_TYPE
591 #define TARGET_MANGLE_FUNDAMENTAL_TYPE rs6000_mangle_fundamental_type
592
593 #undef TARGET_INIT_LIBFUNCS
594 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
595
596 #if TARGET_MACHO
597 #undef TARGET_BINDS_LOCAL_P
598 #define TARGET_BINDS_LOCAL_P rs6000_binds_local_p
599 #endif
600
601 #undef TARGET_ASM_OUTPUT_MI_THUNK
602 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
603
604 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
605 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
606
607 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
608 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
609
610 #undef TARGET_RTX_COSTS
611 #define TARGET_RTX_COSTS rs6000_rtx_costs
612 #undef TARGET_ADDRESS_COST
613 #define TARGET_ADDRESS_COST hook_int_rtx_0
614
615 #undef TARGET_VECTOR_OPAQUE_P
616 #define TARGET_VECTOR_OPAQUE_P is_ev64_opaque_type
617
618 #undef TARGET_DWARF_REGISTER_SPAN
619 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
620
621 /* On rs6000, function arguments are promoted, as are function return
622    values.  */
623 #undef TARGET_PROMOTE_FUNCTION_ARGS
624 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_tree_true
625 #undef TARGET_PROMOTE_FUNCTION_RETURN
626 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
627
628 #undef TARGET_RETURN_IN_MEMORY
629 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
630
631 #undef TARGET_SETUP_INCOMING_VARARGS
632 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
633
634 /* Always strict argument naming on rs6000.  */
635 #undef TARGET_STRICT_ARGUMENT_NAMING
636 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
637 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
638 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
639 #undef TARGET_SPLIT_COMPLEX_ARG
640 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_tree_true
641
642 #undef TARGET_BUILD_BUILTIN_VA_LIST
643 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
644
645 struct gcc_target targetm = TARGET_INITIALIZER;
646 \f
647 /* Override command line options.  Mostly we process the processor
648    type and sometimes adjust other TARGET_ options.  */
649
650 void
651 rs6000_override_options (const char *default_cpu)
652 {
653   size_t i, j;
654   struct rs6000_cpu_select *ptr;
655   int set_masks;
656
657   /* Simplifications for entries below.  */
658
659   enum {
660     POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
661     POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
662   };
663
664   /* This table occasionally claims that a processor does not support
665      a particular feature even though it does, but the feature is slower
666      than the alternative.  Thus, it shouldn't be relied on as a
667      complete description of the processor's support.  
668
669      Please keep this list in order, and don't forget to update the
670      documentation in invoke.texi when adding a new processor or
671      flag.  */
672   static struct ptt
673     {
674       const char *const name;           /* Canonical processor name.  */
675       const enum processor_type processor; /* Processor type enum value.  */
676       const int target_enable;  /* Target flags to enable.  */
677     } const processor_target_table[]
678       = {{"401", PROCESSOR_PPC403, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
679          {"403", PROCESSOR_PPC403,
680           POWERPC_BASE_MASK | MASK_SOFT_FLOAT | MASK_STRICT_ALIGN},
681          {"405", PROCESSOR_PPC405, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
682          {"405fp", PROCESSOR_PPC405, POWERPC_BASE_MASK},
683          {"440", PROCESSOR_PPC440, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
684          {"440fp", PROCESSOR_PPC440, POWERPC_BASE_MASK},
685          {"505", PROCESSOR_MPCCORE, POWERPC_BASE_MASK},
686          {"601", PROCESSOR_PPC601,
687           MASK_POWER | POWERPC_BASE_MASK | MASK_MULTIPLE | MASK_STRING},
688          {"602", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
689          {"603", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
690          {"603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
691          {"604", PROCESSOR_PPC604, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
692          {"604e", PROCESSOR_PPC604e, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
693          {"620", PROCESSOR_PPC620,
694           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
695          {"630", PROCESSOR_PPC630,
696           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
697          {"740", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
698          {"7400", PROCESSOR_PPC7400, POWERPC_7400_MASK},
699          {"7450", PROCESSOR_PPC7450, POWERPC_7400_MASK},
700          {"750", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
701          {"801", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
702          {"821", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
703          {"823", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
704          {"8540", PROCESSOR_PPC8540, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
705          {"860", PROCESSOR_MPCCORE, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
706          {"970", PROCESSOR_POWER4,
707           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
708          {"common", PROCESSOR_COMMON, MASK_NEW_MNEMONICS},
709          {"ec603e", PROCESSOR_PPC603, POWERPC_BASE_MASK | MASK_SOFT_FLOAT},
710          {"G3", PROCESSOR_PPC750, POWERPC_BASE_MASK | MASK_PPC_GFXOPT},
711          {"G4",  PROCESSOR_PPC7450, POWERPC_7400_MASK},
712          {"G5", PROCESSOR_POWER4,
713           POWERPC_7400_MASK | MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64},
714          {"power", PROCESSOR_POWER, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
715          {"power2", PROCESSOR_POWER,
716           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
717          {"power3", PROCESSOR_PPC630,
718           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_POWERPC64},
719          {"power4", PROCESSOR_POWER4,
720           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
721          {"power5", PROCESSOR_POWER5,
722           POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_MFCRF | MASK_POWERPC64},
723          {"powerpc", PROCESSOR_POWERPC, POWERPC_BASE_MASK},
724          {"powerpc64", PROCESSOR_POWERPC64,
725           POWERPC_BASE_MASK | MASK_POWERPC64},
726          {"rios", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
727          {"rios1", PROCESSOR_RIOS1, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
728          {"rios2", PROCESSOR_RIOS2,
729           MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING},
730          {"rsc", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
731          {"rsc1", PROCESSOR_PPC601, MASK_POWER | MASK_MULTIPLE | MASK_STRING},
732          {"rs64a", PROCESSOR_RS64A, POWERPC_BASE_MASK | MASK_POWERPC64},
733       };
734
735   const size_t ptt_size = ARRAY_SIZE (processor_target_table);
736
737   /* Some OSs don't support saving the high part of 64-bit registers on
738      context switch.  Other OSs don't support saving Altivec registers.
739      On those OSs, we don't touch the MASK_POWERPC64 or MASK_ALTIVEC
740      settings; if the user wants either, the user must explicitly specify
741      them and we won't interfere with the user's specification.  */
742
743   enum {
744     POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
745     POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT 
746                      | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
747                      | MASK_MFCRF)
748   };
749  set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
750 #ifdef OS_MISSING_POWERPC64
751   if (OS_MISSING_POWERPC64)
752     set_masks &= ~MASK_POWERPC64;
753 #endif
754 #ifdef OS_MISSING_ALTIVEC
755   if (OS_MISSING_ALTIVEC)
756     set_masks &= ~MASK_ALTIVEC;
757 #endif
758
759   /* Don't override these by the processor default if given explicitly.  */
760   set_masks &= ~(target_flags_explicit
761                  & (MASK_MULTIPLE | MASK_STRING | MASK_SOFT_FLOAT));
762
763   /* Identify the processor type.  */
764   rs6000_select[0].string = default_cpu;
765   rs6000_cpu = TARGET_POWERPC64 ? PROCESSOR_DEFAULT64 : PROCESSOR_DEFAULT;
766
767   for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
768     {
769       ptr = &rs6000_select[i];
770       if (ptr->string != (char *)0 && ptr->string[0] != '\0')
771         {
772           for (j = 0; j < ptt_size; j++)
773             if (! strcmp (ptr->string, processor_target_table[j].name))
774               {
775                 if (ptr->set_tune_p)
776                   rs6000_cpu = processor_target_table[j].processor;
777
778                 if (ptr->set_arch_p)
779                   {
780                     target_flags &= ~set_masks;
781                     target_flags |= (processor_target_table[j].target_enable
782                                      & set_masks);
783                   }
784                 break;
785               }
786
787           if (j == ptt_size)
788             error ("bad value (%s) for %s switch", ptr->string, ptr->name);
789         }
790     }
791
792   if (TARGET_E500)
793     rs6000_isel = 1;
794
795   /* If we are optimizing big endian systems for space, use the load/store
796      multiple and string instructions.  */
797   if (BYTES_BIG_ENDIAN && optimize_size)
798     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
799
800   /* Don't allow -mmultiple or -mstring on little endian systems
801      unless the cpu is a 750, because the hardware doesn't support the
802      instructions used in little endian mode, and causes an alignment
803      trap.  The 750 does not cause an alignment trap (except when the
804      target is unaligned).  */
805
806   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
807     {
808       if (TARGET_MULTIPLE)
809         {
810           target_flags &= ~MASK_MULTIPLE;
811           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
812             warning ("-mmultiple is not supported on little endian systems");
813         }
814
815       if (TARGET_STRING)
816         {
817           target_flags &= ~MASK_STRING;
818           if ((target_flags_explicit & MASK_STRING) != 0)
819             warning ("-mstring is not supported on little endian systems");
820         }
821     }
822
823   /* Set debug flags */
824   if (rs6000_debug_name)
825     {
826       if (! strcmp (rs6000_debug_name, "all"))
827         rs6000_debug_stack = rs6000_debug_arg = 1;
828       else if (! strcmp (rs6000_debug_name, "stack"))
829         rs6000_debug_stack = 1;
830       else if (! strcmp (rs6000_debug_name, "arg"))
831         rs6000_debug_arg = 1;
832       else
833         error ("unknown -mdebug-%s switch", rs6000_debug_name);
834     }
835
836   if (rs6000_traceback_name)
837     {
838       if (! strncmp (rs6000_traceback_name, "full", 4))
839         rs6000_traceback = traceback_full;
840       else if (! strncmp (rs6000_traceback_name, "part", 4))
841         rs6000_traceback = traceback_part;
842       else if (! strncmp (rs6000_traceback_name, "no", 2))
843         rs6000_traceback = traceback_none;
844       else
845         error ("unknown -mtraceback arg `%s'; expecting `full', `partial' or `none'",
846                rs6000_traceback_name);
847     }
848
849   /* Set size of long double */
850   rs6000_long_double_type_size = 64;
851   if (rs6000_long_double_size_string)
852     {
853       char *tail;
854       int size = strtol (rs6000_long_double_size_string, &tail, 10);
855       if (*tail != '\0' || (size != 64 && size != 128))
856         error ("Unknown switch -mlong-double-%s",
857                rs6000_long_double_size_string);
858       else
859         rs6000_long_double_type_size = size;
860     }
861
862   /* Set Altivec ABI as default for powerpc64 linux.  */
863   if (TARGET_ELF && TARGET_64BIT)
864     {
865       rs6000_altivec_abi = 1;
866       rs6000_altivec_vrsave = 1;
867     }
868
869   /* Handle -mabi= options.  */
870   rs6000_parse_abi_options ();
871
872   /* Handle -malign-XXXXX option.  */
873   rs6000_parse_alignment_option ();
874
875   /* Handle generic -mFOO=YES/NO options.  */
876   rs6000_parse_yes_no_option ("vrsave", rs6000_altivec_vrsave_string,
877                               &rs6000_altivec_vrsave);
878   rs6000_parse_yes_no_option ("isel", rs6000_isel_string,
879                               &rs6000_isel);
880   rs6000_parse_yes_no_option ("spe", rs6000_spe_string, &rs6000_spe);
881   rs6000_parse_yes_no_option ("float-gprs", rs6000_float_gprs_string,
882                               &rs6000_float_gprs);
883
884   /* Handle -mtls-size option.  */
885   rs6000_parse_tls_size_option ();
886
887 #ifdef SUBTARGET_OVERRIDE_OPTIONS
888   SUBTARGET_OVERRIDE_OPTIONS;
889 #endif
890 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
891   SUBSUBTARGET_OVERRIDE_OPTIONS;
892 #endif
893
894   if (TARGET_E500)
895     {
896       if (TARGET_ALTIVEC)
897         error ("AltiVec and E500 instructions cannot coexist");
898
899       /* The e500 does not have string instructions, and we set
900          MASK_STRING above when optimizing for size.  */
901       if ((target_flags & MASK_STRING) != 0)
902         target_flags = target_flags & ~MASK_STRING;
903
904       /* No SPE means 64-bit long doubles, even if an E500.  */
905       if (rs6000_spe_string != 0
906           && !strcmp (rs6000_spe_string, "no"))
907         rs6000_long_double_type_size = 64;
908     }
909   else if (rs6000_select[1].string != NULL)
910     {
911       /* For the powerpc-eabispe configuration, we set all these by
912          default, so let's unset them if we manually set another
913          CPU that is not the E500.  */
914       if (rs6000_abi_string == 0)
915         rs6000_spe_abi = 0;
916       if (rs6000_spe_string == 0)
917         rs6000_spe = 0;
918       if (rs6000_float_gprs_string == 0)
919         rs6000_float_gprs = 0;
920       if (rs6000_isel_string == 0)
921         rs6000_isel = 0;
922       if (rs6000_long_double_size_string == 0)
923         rs6000_long_double_type_size = 64;
924     }
925
926   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
927                         && rs6000_cpu != PROCESSOR_POWER5);
928   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
929                          || rs6000_cpu == PROCESSOR_POWER5);
930
931   /* Handle -m(no-)longcall option.  This is a bit of a cheap hack,
932      using TARGET_OPTIONS to handle a toggle switch, but we're out of
933      bits in target_flags so TARGET_SWITCHES cannot be used.
934      Assumption here is that rs6000_longcall_switch points into the
935      text of the complete option, rather than being a copy, so we can
936      scan back for the presence or absence of the no- modifier.  */
937   if (rs6000_longcall_switch)
938     {
939       const char *base = rs6000_longcall_switch;
940       while (base[-1] != 'm') base--;
941
942       if (*rs6000_longcall_switch != '\0')
943         error ("invalid option `%s'", base);
944       rs6000_default_long_calls = (base[0] != 'n');
945     }
946
947   /* Handle -m(no-)warn-altivec-long similarly.  */
948   if (rs6000_warn_altivec_long_switch)
949     {
950       const char *base = rs6000_warn_altivec_long_switch;
951       while (base[-1] != 'm') base--;
952
953       if (*rs6000_warn_altivec_long_switch != '\0')
954         error ("invalid option `%s'", base);
955       rs6000_warn_altivec_long = (base[0] != 'n');
956     }
957
958   /* Handle -mprioritize-restricted-insns option.  */
959   rs6000_sched_restricted_insns_priority
960     = (rs6000_sched_groups ? 1 : 0);
961   if (rs6000_sched_restricted_insns_priority_str)
962     rs6000_sched_restricted_insns_priority =
963       atoi (rs6000_sched_restricted_insns_priority_str);
964
965   /* Handle -msched-costly-dep option.  */
966   rs6000_sched_costly_dep
967     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
968   if (rs6000_sched_costly_dep_str)
969     {
970       if (! strcmp (rs6000_sched_costly_dep_str, "no"))  
971         rs6000_sched_costly_dep = no_dep_costly;
972       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
973         rs6000_sched_costly_dep = all_deps_costly;
974       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
975         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
976       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
977         rs6000_sched_costly_dep = store_to_load_dep_costly;
978       else 
979         rs6000_sched_costly_dep = atoi (rs6000_sched_costly_dep_str);
980     }
981
982   /* Handle -minsert-sched-nops option.  */
983   rs6000_sched_insert_nops
984     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
985   if (rs6000_sched_insert_nops_str)
986     {
987       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
988         rs6000_sched_insert_nops = sched_finish_none;
989       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
990         rs6000_sched_insert_nops = sched_finish_pad_groups;
991       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
992         rs6000_sched_insert_nops = sched_finish_regroup_exact;
993       else
994         rs6000_sched_insert_nops = atoi (rs6000_sched_insert_nops_str);
995     }
996
997 #ifdef TARGET_REGNAMES
998   /* If the user desires alternate register names, copy in the
999      alternate names now.  */
1000   if (TARGET_REGNAMES)
1001     memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
1002 #endif
1003
1004   /* Set TARGET_AIX_STRUCT_RET last, after the ABI is determined.
1005      If -maix-struct-return or -msvr4-struct-return was explicitly
1006      used, don't override with the ABI default.  */
1007   if ((target_flags_explicit & MASK_AIX_STRUCT_RET) == 0)
1008     {
1009       if (DEFAULT_ABI == ABI_V4 && !DRAFT_V4_STRUCT_RET)
1010         target_flags = (target_flags & ~MASK_AIX_STRUCT_RET);
1011       else
1012         target_flags |= MASK_AIX_STRUCT_RET;
1013     }
1014
1015   if (TARGET_LONG_DOUBLE_128
1016       && (DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN))
1017     REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
1018
1019   /* Allocate an alias set for register saves & restores from stack.  */
1020   rs6000_sr_alias_set = new_alias_set ();
1021
1022   if (TARGET_TOC) 
1023     ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
1024
1025   /* We can only guarantee the availability of DI pseudo-ops when
1026      assembling for 64-bit targets.  */
1027   if (!TARGET_64BIT)
1028     {
1029       targetm.asm_out.aligned_op.di = NULL;
1030       targetm.asm_out.unaligned_op.di = NULL;
1031     }
1032
1033   /* Set maximum branch target alignment at two instructions, eight bytes.  */
1034   align_jumps_max_skip = 8;
1035   align_loops_max_skip = 8;
1036
1037   /* Arrange to save and restore machine status around nested functions.  */
1038   init_machine_status = rs6000_init_machine_status;
1039
1040   /* We should always be splitting complex arguments, but we can't break
1041      Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
1042   if (DEFAULT_ABI != ABI_AIX)
1043     targetm.calls.split_complex_arg = NULL;
1044 }
1045
1046 /* Handle generic options of the form -mfoo=yes/no.
1047    NAME is the option name.
1048    VALUE is the option value.
1049    FLAG is the pointer to the flag where to store a 1 or 0, depending on
1050    whether the option value is 'yes' or 'no' respectively.  */
1051 static void
1052 rs6000_parse_yes_no_option (const char *name, const char *value, int *flag)
1053 {
1054   if (value == 0)
1055     return;
1056   else if (!strcmp (value, "yes"))
1057     *flag = 1;
1058   else if (!strcmp (value, "no"))
1059     *flag = 0;
1060   else
1061     error ("unknown -m%s= option specified: '%s'", name, value);
1062 }
1063
1064 /* Handle -mabi= options.  */
1065 static void
1066 rs6000_parse_abi_options (void)
1067 {
1068   if (rs6000_abi_string == 0)
1069     return;
1070   else if (! strcmp (rs6000_abi_string, "altivec"))
1071     {
1072       rs6000_altivec_abi = 1;
1073       rs6000_spe_abi = 0;
1074     }
1075   else if (! strcmp (rs6000_abi_string, "no-altivec"))
1076     rs6000_altivec_abi = 0;
1077   else if (! strcmp (rs6000_abi_string, "spe"))
1078     {
1079       rs6000_spe_abi = 1;
1080       rs6000_altivec_abi = 0;
1081       if (!TARGET_SPE_ABI)
1082         error ("not configured for ABI: '%s'", rs6000_abi_string);
1083     }
1084   
1085   else if (! strcmp (rs6000_abi_string, "no-spe"))
1086     rs6000_spe_abi = 0;
1087   else
1088     error ("unknown ABI specified: '%s'", rs6000_abi_string);
1089 }
1090
1091 /* Handle -malign-XXXXXX options.  */
1092 static void
1093 rs6000_parse_alignment_option (void)
1094 {
1095   if (rs6000_alignment_string == 0)
1096     return;
1097   else if (! strcmp (rs6000_alignment_string, "power"))
1098     rs6000_alignment_flags = MASK_ALIGN_POWER;
1099   else if (! strcmp (rs6000_alignment_string, "natural"))
1100     rs6000_alignment_flags = MASK_ALIGN_NATURAL;
1101   else
1102     error ("unknown -malign-XXXXX option specified: '%s'",
1103            rs6000_alignment_string);
1104 }
1105
1106 /* Validate and record the size specified with the -mtls-size option.  */
1107
1108 static void
1109 rs6000_parse_tls_size_option (void)
1110 {
1111   if (rs6000_tls_size_string == 0)
1112     return;
1113   else if (strcmp (rs6000_tls_size_string, "16") == 0)
1114     rs6000_tls_size = 16;
1115   else if (strcmp (rs6000_tls_size_string, "32") == 0)
1116     rs6000_tls_size = 32;
1117   else if (strcmp (rs6000_tls_size_string, "64") == 0)
1118     rs6000_tls_size = 64;
1119   else
1120     error ("bad value `%s' for -mtls-size switch", rs6000_tls_size_string);
1121 }
1122
1123 void
1124 optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
1125 {
1126 }
1127 \f
1128 /* Do anything needed at the start of the asm file.  */
1129
1130 static void
1131 rs6000_file_start (void)
1132 {
1133   size_t i;
1134   char buffer[80];
1135   const char *start = buffer;
1136   struct rs6000_cpu_select *ptr;
1137   const char *default_cpu = TARGET_CPU_DEFAULT;
1138   FILE *file = asm_out_file;
1139
1140   default_file_start ();
1141
1142 #ifdef TARGET_BI_ARCH
1143   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
1144     default_cpu = 0;
1145 #endif
1146
1147   if (flag_verbose_asm)
1148     {
1149       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
1150       rs6000_select[0].string = default_cpu;
1151
1152       for (i = 0; i < ARRAY_SIZE (rs6000_select); i++)
1153         {
1154           ptr = &rs6000_select[i];
1155           if (ptr->string != (char *)0 && ptr->string[0] != '\0')
1156             {
1157               fprintf (file, "%s %s%s", start, ptr->name, ptr->string);
1158               start = "";
1159             }
1160         }
1161
1162 #ifdef USING_ELFOS_H
1163       switch (rs6000_sdata)
1164         {
1165         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
1166         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
1167         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
1168         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
1169         }
1170
1171       if (rs6000_sdata && g_switch_value)
1172         {
1173           fprintf (file, "%s -G " HOST_WIDE_INT_PRINT_UNSIGNED, start,
1174                    g_switch_value);
1175           start = "";
1176         }
1177 #endif
1178
1179       if (*start == '\0')
1180         putc ('\n', file);
1181     }
1182 }
1183 \f
1184 /* Return nonzero if this function is known to have a null epilogue.  */
1185
1186 int
1187 direct_return (void)
1188 {
1189   if (reload_completed)
1190     {
1191       rs6000_stack_t *info = rs6000_stack_info ();
1192
1193       if (info->first_gp_reg_save == 32
1194           && info->first_fp_reg_save == 64
1195           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
1196           && ! info->lr_save_p
1197           && ! info->cr_save_p
1198           && info->vrsave_mask == 0
1199           && ! info->push_p)
1200         return 1;
1201     }
1202
1203   return 0;
1204 }
1205
1206 /* Returns 1 always.  */
1207
1208 int
1209 any_operand (rtx op ATTRIBUTE_UNUSED, 
1210              enum machine_mode mode ATTRIBUTE_UNUSED)
1211 {
1212   return 1;
1213 }
1214
1215 /* Returns 1 if op is the count register.  */
1216 int
1217 count_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1218 {
1219   if (GET_CODE (op) != REG)
1220     return 0;
1221
1222   if (REGNO (op) == COUNT_REGISTER_REGNUM)
1223     return 1;
1224
1225   if (REGNO (op) > FIRST_PSEUDO_REGISTER)
1226     return 1;
1227
1228   return 0;
1229 }
1230
1231 /* Returns 1 if op is an altivec register.  */
1232 int
1233 altivec_register_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1234 {
1235   
1236   return (register_operand (op, mode)
1237           && (GET_CODE (op) != REG
1238               || REGNO (op) > FIRST_PSEUDO_REGISTER
1239               || ALTIVEC_REGNO_P (REGNO (op))));
1240 }
1241
1242 int
1243 xer_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1244 {
1245   if (GET_CODE (op) != REG)
1246     return 0;
1247
1248   if (XER_REGNO_P (REGNO (op)))
1249     return 1;
1250
1251   return 0;
1252 }
1253
1254 /* Return 1 if OP is a signed 8-bit constant.  Int multiplication
1255    by such constants completes more quickly.  */
1256
1257 int
1258 s8bit_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1259 {
1260   return ( GET_CODE (op) == CONST_INT
1261           && (INTVAL (op) >= -128 && INTVAL (op) <= 127));
1262 }
1263
1264 /* Return 1 if OP is a constant that can fit in a D field.  */
1265
1266 int
1267 short_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1268 {
1269   return (GET_CODE (op) == CONST_INT
1270           && CONST_OK_FOR_LETTER_P (INTVAL (op), 'I'));
1271 }
1272
1273 /* Similar for an unsigned D field.  */
1274
1275 int
1276 u_short_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1277 {
1278   return (GET_CODE (op) == CONST_INT
1279           && CONST_OK_FOR_LETTER_P (INTVAL (op) & GET_MODE_MASK (mode), 'K'));
1280 }
1281
1282 /* Return 1 if OP is a CONST_INT that cannot fit in a signed D field.  */
1283
1284 int
1285 non_short_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1286 {
1287   return (GET_CODE (op) == CONST_INT
1288           && (unsigned HOST_WIDE_INT) (INTVAL (op) + 0x8000) >= 0x10000);
1289 }
1290
1291 /* Returns 1 if OP is a CONST_INT that is a positive value
1292    and an exact power of 2.  */
1293
1294 int
1295 exact_log2_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1296 {
1297   return (GET_CODE (op) == CONST_INT
1298           && INTVAL (op) > 0
1299           && exact_log2 (INTVAL (op)) >= 0);
1300 }
1301
1302 /* Returns 1 if OP is a register that is not special (i.e., not MQ,
1303    ctr, or lr).  */
1304
1305 int
1306 gpc_reg_operand (rtx op, enum machine_mode mode)
1307 {
1308   return (register_operand (op, mode)
1309           && (GET_CODE (op) != REG
1310               || (REGNO (op) >= ARG_POINTER_REGNUM 
1311                   && !XER_REGNO_P (REGNO (op)))
1312               || REGNO (op) < MQ_REGNO));
1313 }
1314
1315 /* Returns 1 if OP is either a pseudo-register or a register denoting a
1316    CR field.  */
1317
1318 int
1319 cc_reg_operand (rtx op, enum machine_mode mode)
1320 {
1321   return (register_operand (op, mode)
1322           && (GET_CODE (op) != REG
1323               || REGNO (op) >= FIRST_PSEUDO_REGISTER
1324               || CR_REGNO_P (REGNO (op))));
1325 }
1326
1327 /* Returns 1 if OP is either a pseudo-register or a register denoting a
1328    CR field that isn't CR0.  */
1329
1330 int
1331 cc_reg_not_cr0_operand (rtx op, enum machine_mode mode)
1332 {
1333   return (register_operand (op, mode)
1334           && (GET_CODE (op) != REG
1335               || REGNO (op) >= FIRST_PSEUDO_REGISTER
1336               || CR_REGNO_NOT_CR0_P (REGNO (op))));
1337 }
1338
1339 /* Returns 1 if OP is either a constant integer valid for a D-field or
1340    a non-special register.  If a register, it must be in the proper
1341    mode unless MODE is VOIDmode.  */
1342
1343 int
1344 reg_or_short_operand (rtx op, enum machine_mode mode)
1345 {
1346   return short_cint_operand (op, mode) || gpc_reg_operand (op, mode);
1347 }
1348
1349 /* Similar, except check if the negation of the constant would be
1350    valid for a D-field.  */
1351
1352 int
1353 reg_or_neg_short_operand (rtx op, enum machine_mode mode)
1354 {
1355   if (GET_CODE (op) == CONST_INT)
1356     return CONST_OK_FOR_LETTER_P (INTVAL (op), 'P');
1357
1358   return gpc_reg_operand (op, mode);
1359 }
1360
1361 /* Returns 1 if OP is either a constant integer valid for a DS-field or
1362    a non-special register.  If a register, it must be in the proper
1363    mode unless MODE is VOIDmode.  */
1364
1365 int
1366 reg_or_aligned_short_operand (rtx op, enum machine_mode mode)
1367 {
1368   if (gpc_reg_operand (op, mode))
1369     return 1;
1370   else if (short_cint_operand (op, mode) && !(INTVAL (op) & 3))
1371     return 1;
1372
1373   return 0;
1374 }
1375
1376
1377 /* Return 1 if the operand is either a register or an integer whose
1378    high-order 16 bits are zero.  */
1379
1380 int
1381 reg_or_u_short_operand (rtx op, enum machine_mode mode)
1382 {
1383   return u_short_cint_operand (op, mode) || gpc_reg_operand (op, mode);
1384 }
1385
1386 /* Return 1 is the operand is either a non-special register or ANY
1387    constant integer.  */
1388
1389 int
1390 reg_or_cint_operand (rtx op, enum machine_mode mode)
1391 {
1392   return (GET_CODE (op) == CONST_INT || gpc_reg_operand (op, mode));
1393 }
1394
1395 /* Return 1 is the operand is either a non-special register or ANY
1396    32-bit signed constant integer.  */
1397
1398 int
1399 reg_or_arith_cint_operand (rtx op, enum machine_mode mode)
1400 {
1401   return (gpc_reg_operand (op, mode)
1402           || (GET_CODE (op) == CONST_INT
1403 #if HOST_BITS_PER_WIDE_INT != 32
1404               && ((unsigned HOST_WIDE_INT) (INTVAL (op) + 0x80000000)
1405                   < (unsigned HOST_WIDE_INT) 0x100000000ll)
1406 #endif
1407               ));
1408 }
1409
1410 /* Return 1 is the operand is either a non-special register or a 32-bit
1411    signed constant integer valid for 64-bit addition.  */
1412
1413 int
1414 reg_or_add_cint64_operand (rtx op, enum machine_mode mode)
1415 {
1416   return (gpc_reg_operand (op, mode)
1417           || (GET_CODE (op) == CONST_INT
1418 #if HOST_BITS_PER_WIDE_INT == 32
1419               && INTVAL (op) < 0x7fff8000
1420 #else
1421               && ((unsigned HOST_WIDE_INT) (INTVAL (op) + 0x80008000)
1422                   < 0x100000000ll)
1423 #endif
1424               ));
1425 }
1426
1427 /* Return 1 is the operand is either a non-special register or a 32-bit
1428    signed constant integer valid for 64-bit subtraction.  */
1429
1430 int
1431 reg_or_sub_cint64_operand (rtx op, enum machine_mode mode)
1432 {
1433   return (gpc_reg_operand (op, mode)
1434           || (GET_CODE (op) == CONST_INT
1435 #if HOST_BITS_PER_WIDE_INT == 32
1436               && (- INTVAL (op)) < 0x7fff8000
1437 #else
1438               && ((unsigned HOST_WIDE_INT) ((- INTVAL (op)) + 0x80008000)
1439                   < 0x100000000ll)
1440 #endif
1441               ));
1442 }
1443
1444 /* Return 1 is the operand is either a non-special register or ANY
1445    32-bit unsigned constant integer.  */
1446
1447 int
1448 reg_or_logical_cint_operand (rtx op, enum machine_mode mode)
1449 {
1450   if (GET_CODE (op) == CONST_INT)
1451     {
1452       if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT)
1453         {
1454           if (GET_MODE_BITSIZE (mode) <= 32)
1455             abort ();
1456
1457           if (INTVAL (op) < 0)
1458             return 0;
1459         }
1460
1461       return ((INTVAL (op) & GET_MODE_MASK (mode)
1462                & (~ (unsigned HOST_WIDE_INT) 0xffffffff)) == 0);
1463     }
1464   else if (GET_CODE (op) == CONST_DOUBLE)
1465     {
1466       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1467           || mode != DImode)
1468         abort ();
1469
1470       return CONST_DOUBLE_HIGH (op) == 0;
1471     }
1472   else 
1473     return gpc_reg_operand (op, mode);
1474 }
1475
1476 /* Return 1 if the operand is an operand that can be loaded via the GOT.  */
1477
1478 int
1479 got_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1480 {
1481   return (GET_CODE (op) == SYMBOL_REF
1482           || GET_CODE (op) == CONST
1483           || GET_CODE (op) == LABEL_REF);
1484 }
1485
1486 /* Return 1 if the operand is a simple references that can be loaded via
1487    the GOT (labels involving addition aren't allowed).  */
1488
1489 int
1490 got_no_const_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1491 {
1492   return (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF);
1493 }
1494
1495 /* Return the number of instructions it takes to form a constant in an
1496    integer register.  */
1497
1498 static int
1499 num_insns_constant_wide (HOST_WIDE_INT value)
1500 {
1501   /* signed constant loadable with {cal|addi} */
1502   if (CONST_OK_FOR_LETTER_P (value, 'I'))
1503     return 1;
1504
1505   /* constant loadable with {cau|addis} */
1506   else if (CONST_OK_FOR_LETTER_P (value, 'L'))
1507     return 1;
1508
1509 #if HOST_BITS_PER_WIDE_INT == 64
1510   else if (TARGET_POWERPC64)
1511     {
1512       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
1513       HOST_WIDE_INT high = value >> 31;
1514
1515       if (high == 0 || high == -1)
1516         return 2;
1517
1518       high >>= 1;
1519
1520       if (low == 0)
1521         return num_insns_constant_wide (high) + 1;
1522       else
1523         return (num_insns_constant_wide (high)
1524                 + num_insns_constant_wide (low) + 1);
1525     }
1526 #endif
1527
1528   else
1529     return 2;
1530 }
1531
1532 int
1533 num_insns_constant (rtx op, enum machine_mode mode)
1534 {
1535   if (GET_CODE (op) == CONST_INT)
1536     {
1537 #if HOST_BITS_PER_WIDE_INT == 64
1538       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
1539           && mask64_operand (op, mode))
1540             return 2;
1541       else
1542 #endif
1543         return num_insns_constant_wide (INTVAL (op));
1544     }
1545
1546   else if (GET_CODE (op) == CONST_DOUBLE && mode == SFmode)
1547     {
1548       long l;
1549       REAL_VALUE_TYPE rv;
1550
1551       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1552       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1553       return num_insns_constant_wide ((HOST_WIDE_INT) l);
1554     }
1555
1556   else if (GET_CODE (op) == CONST_DOUBLE)
1557     {
1558       HOST_WIDE_INT low;
1559       HOST_WIDE_INT high;
1560       long l[2];
1561       REAL_VALUE_TYPE rv;
1562       int endian = (WORDS_BIG_ENDIAN == 0);
1563
1564       if (mode == VOIDmode || mode == DImode)
1565         {
1566           high = CONST_DOUBLE_HIGH (op);
1567           low  = CONST_DOUBLE_LOW (op);
1568         }
1569       else
1570         {
1571           REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1572           REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
1573           high = l[endian];
1574           low  = l[1 - endian];
1575         }
1576
1577       if (TARGET_32BIT)
1578         return (num_insns_constant_wide (low)
1579                 + num_insns_constant_wide (high));
1580
1581       else
1582         {
1583           if (high == 0 && low >= 0)
1584             return num_insns_constant_wide (low);
1585
1586           else if (high == -1 && low < 0)
1587             return num_insns_constant_wide (low);
1588
1589           else if (mask64_operand (op, mode))
1590             return 2;
1591
1592           else if (low == 0)
1593             return num_insns_constant_wide (high) + 1;
1594
1595           else
1596             return (num_insns_constant_wide (high)
1597                     + num_insns_constant_wide (low) + 1);
1598         }
1599     }
1600
1601   else
1602     abort ();
1603 }
1604
1605 /* Return 1 if the operand is a CONST_DOUBLE and it can be put into a
1606    register with one instruction per word.  We only do this if we can
1607    safely read CONST_DOUBLE_{LOW,HIGH}.  */
1608
1609 int
1610 easy_fp_constant (rtx op, enum machine_mode mode)
1611 {
1612   if (GET_CODE (op) != CONST_DOUBLE
1613       || GET_MODE (op) != mode
1614       || (GET_MODE_CLASS (mode) != MODE_FLOAT && mode != DImode))
1615     return 0;
1616
1617   /* Consider all constants with -msoft-float to be easy.  */
1618   if ((TARGET_SOFT_FLOAT || !TARGET_FPRS)
1619       && mode != DImode)
1620     return 1;
1621
1622   /* If we are using V.4 style PIC, consider all constants to be hard.  */
1623   if (flag_pic && DEFAULT_ABI == ABI_V4)
1624     return 0;
1625
1626 #ifdef TARGET_RELOCATABLE
1627   /* Similarly if we are using -mrelocatable, consider all constants
1628      to be hard.  */
1629   if (TARGET_RELOCATABLE)
1630     return 0;
1631 #endif
1632
1633   if (mode == TFmode)
1634     {
1635       long k[4];
1636       REAL_VALUE_TYPE rv;
1637
1638       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1639       REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
1640
1641       return (num_insns_constant_wide ((HOST_WIDE_INT) k[0]) == 1
1642               && num_insns_constant_wide ((HOST_WIDE_INT) k[1]) == 1
1643               && num_insns_constant_wide ((HOST_WIDE_INT) k[2]) == 1
1644               && num_insns_constant_wide ((HOST_WIDE_INT) k[3]) == 1);
1645     }
1646
1647   else if (mode == DFmode)
1648     {
1649       long k[2];
1650       REAL_VALUE_TYPE rv;
1651
1652       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1653       REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
1654
1655       return (num_insns_constant_wide ((HOST_WIDE_INT) k[0]) == 1
1656               && num_insns_constant_wide ((HOST_WIDE_INT) k[1]) == 1);
1657     }
1658
1659   else if (mode == SFmode)
1660     {
1661       long l;
1662       REAL_VALUE_TYPE rv;
1663
1664       REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
1665       REAL_VALUE_TO_TARGET_SINGLE (rv, l);
1666
1667       return num_insns_constant_wide (l) == 1;
1668     }
1669
1670   else if (mode == DImode)
1671     return ((TARGET_POWERPC64
1672              && GET_CODE (op) == CONST_DOUBLE && CONST_DOUBLE_LOW (op) == 0)
1673             || (num_insns_constant (op, DImode) <= 2));
1674
1675   else if (mode == SImode)
1676     return 1;
1677   else
1678     abort ();
1679 }
1680
1681 /* Returns the constant for the splat instruction, if exists.  */
1682
1683 static int
1684 easy_vector_splat_const (int cst, enum machine_mode mode)
1685 {
1686   switch (mode) 
1687     {
1688     case V4SImode:
1689       if (EASY_VECTOR_15 (cst) 
1690           || EASY_VECTOR_15_ADD_SELF (cst)) 
1691         return cst;
1692       if ((cst & 0xffff) != ((cst >> 16) & 0xffff))
1693         break;
1694       cst = cst >> 16;
1695     case V8HImode:
1696       if (EASY_VECTOR_15 (cst) 
1697           || EASY_VECTOR_15_ADD_SELF (cst)) 
1698         return cst;
1699       if ((cst & 0xff) != ((cst >> 8) & 0xff))
1700         break;
1701       cst = cst >> 8;
1702     case V16QImode:
1703           if (EASY_VECTOR_15 (cst) 
1704               || EASY_VECTOR_15_ADD_SELF (cst)) 
1705             return cst;
1706     default: 
1707       break;
1708     }
1709   return 0;
1710 }
1711
1712
1713 /* Return nonzero if all elements of a vector have the same value.  */
1714
1715 static int
1716 easy_vector_same (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1717 {
1718   int units, i, cst;
1719
1720   units = CONST_VECTOR_NUNITS (op);
1721
1722   cst = INTVAL (CONST_VECTOR_ELT (op, 0));
1723   for (i = 1; i < units; ++i)
1724     if (INTVAL (CONST_VECTOR_ELT (op, i)) != cst)
1725       break;
1726   if (i == units && easy_vector_splat_const (cst, mode))
1727     return 1;
1728   return 0;
1729 }
1730
1731 /* Return 1 if the operand is a CONST_INT and can be put into a
1732    register without using memory.  */
1733
1734 int
1735 easy_vector_constant (rtx op, enum machine_mode mode)
1736 {
1737   int cst, cst2;
1738
1739   if (GET_CODE (op) != CONST_VECTOR
1740       || (!TARGET_ALTIVEC
1741           && !TARGET_SPE))
1742     return 0;
1743
1744   if (zero_constant (op, mode)
1745       && ((TARGET_ALTIVEC && ALTIVEC_VECTOR_MODE (mode))
1746           || (TARGET_SPE && SPE_VECTOR_MODE (mode))))
1747     return 1;
1748
1749   if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT)
1750     return 0;
1751
1752   if (TARGET_SPE && mode == V1DImode)
1753     return 0;
1754
1755   cst  = INTVAL (CONST_VECTOR_ELT (op, 0));
1756   cst2 = INTVAL (CONST_VECTOR_ELT (op, 1));
1757
1758   /* Limit SPE vectors to 15 bits signed.  These we can generate with:
1759        li r0, CONSTANT1
1760        evmergelo r0, r0, r0
1761        li r0, CONSTANT2
1762
1763      I don't know how efficient it would be to allow bigger constants,
1764      considering we'll have an extra 'ori' for every 'li'.  I doubt 5
1765      instructions is better than a 64-bit memory load, but I don't
1766      have the e500 timing specs.  */
1767   if (TARGET_SPE && mode == V2SImode
1768       && cst  >= -0x7fff && cst <= 0x7fff
1769       && cst2 >= -0x7fff && cst2 <= 0x7fff)
1770     return 1;
1771
1772   if (TARGET_ALTIVEC 
1773       && easy_vector_same (op, mode))
1774     {
1775       cst = easy_vector_splat_const (cst, mode);
1776       if (EASY_VECTOR_15_ADD_SELF (cst) 
1777           || EASY_VECTOR_15 (cst))
1778         return 1;
1779     }  
1780   return 0;
1781 }
1782
1783 /* Same as easy_vector_constant but only for EASY_VECTOR_15_ADD_SELF.  */
1784
1785 int
1786 easy_vector_constant_add_self (rtx op, enum machine_mode mode)
1787 {
1788   int cst;
1789   if (TARGET_ALTIVEC
1790       && GET_CODE (op) == CONST_VECTOR
1791       && easy_vector_same (op, mode))
1792     {
1793       cst = easy_vector_splat_const (INTVAL (CONST_VECTOR_ELT (op, 0)), mode);
1794       if (EASY_VECTOR_15_ADD_SELF (cst))
1795         return 1;  
1796     }
1797   return 0;
1798 }
1799
1800 /* Generate easy_vector_constant out of a easy_vector_constant_add_self.  */
1801
1802 rtx 
1803 gen_easy_vector_constant_add_self (rtx op)
1804 {
1805   int i, units;
1806   rtvec v;
1807   units = GET_MODE_NUNITS (GET_MODE (op));
1808   v = rtvec_alloc (units);
1809
1810   for (i = 0; i < units; i++)
1811     RTVEC_ELT (v, i) = 
1812       GEN_INT (INTVAL (CONST_VECTOR_ELT (op, i)) >> 1);
1813   return gen_rtx_raw_CONST_VECTOR (GET_MODE (op), v);
1814 }
1815
1816 const char *
1817 output_vec_const_move (rtx *operands)
1818 {
1819   int cst, cst2;
1820   enum machine_mode mode;
1821   rtx dest, vec;
1822
1823   dest = operands[0];
1824   vec = operands[1];
1825
1826   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
1827   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
1828   mode = GET_MODE (dest);
1829
1830   if (TARGET_ALTIVEC)
1831     {
1832       if (zero_constant (vec, mode))
1833         return "vxor %0,%0,%0";
1834       else if (easy_vector_constant (vec, mode))
1835         {
1836           operands[1] = GEN_INT (cst);
1837           switch (mode)
1838             {
1839             case V4SImode:
1840               if (EASY_VECTOR_15 (cst))
1841                 {
1842                   operands[1] = GEN_INT (cst);
1843                   return "vspltisw %0,%1";
1844                 }
1845               else if (EASY_VECTOR_15_ADD_SELF (cst))
1846                 return "#";
1847               cst = cst >> 16;
1848             case V8HImode:
1849               if (EASY_VECTOR_15 (cst))
1850                 {
1851                   operands[1] = GEN_INT (cst);
1852                   return "vspltish %0,%1";
1853                 }
1854               else if (EASY_VECTOR_15_ADD_SELF (cst))
1855                 return "#";
1856               cst = cst >> 8;
1857             case V16QImode:
1858               if (EASY_VECTOR_15 (cst))
1859                 {
1860                   operands[1] = GEN_INT (cst);
1861                   return "vspltisb %0,%1";
1862                 }
1863               else if (EASY_VECTOR_15_ADD_SELF (cst))
1864                 return "#";
1865             default:
1866               abort ();
1867             }
1868         }
1869       else
1870         abort ();
1871     }
1872
1873   if (TARGET_SPE)
1874     {
1875       /* Vector constant 0 is handled as a splitter of V2SI, and in the
1876          pattern of V1DI, V4HI, and V2SF.
1877
1878          FIXME: We should probably return # and add post reload
1879          splitters for these, but this way is so easy ;-).
1880       */
1881       operands[1] = GEN_INT (cst);
1882       operands[2] = GEN_INT (cst2);
1883       if (cst == cst2)
1884         return "li %0,%1\n\tevmergelo %0,%0,%0";
1885       else
1886         return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
1887     }
1888
1889   abort ();
1890 }
1891
1892 /* Return 1 if the operand is the constant 0.  This works for scalars
1893    as well as vectors.  */
1894 int
1895 zero_constant (rtx op, enum machine_mode mode)
1896 {
1897   return op == CONST0_RTX (mode);
1898 }
1899
1900 /* Return 1 if the operand is 0.0.  */
1901 int
1902 zero_fp_constant (rtx op, enum machine_mode mode)
1903 {
1904   return GET_MODE_CLASS (mode) == MODE_FLOAT && op == CONST0_RTX (mode);
1905 }
1906
1907 /* Return 1 if the operand is in volatile memory.  Note that during
1908    the RTL generation phase, memory_operand does not return TRUE for
1909    volatile memory references.  So this function allows us to
1910    recognize volatile references where its safe.  */
1911
1912 int
1913 volatile_mem_operand (rtx op, enum machine_mode mode)
1914 {
1915   if (GET_CODE (op) != MEM)
1916     return 0;
1917
1918   if (!MEM_VOLATILE_P (op))
1919     return 0;
1920
1921   if (mode != GET_MODE (op))
1922     return 0;
1923
1924   if (reload_completed)
1925     return memory_operand (op, mode);
1926
1927   if (reload_in_progress)
1928     return strict_memory_address_p (mode, XEXP (op, 0));
1929
1930   return memory_address_p (mode, XEXP (op, 0));
1931 }
1932
1933 /* Return 1 if the operand is an offsettable memory operand.  */
1934
1935 int
1936 offsettable_mem_operand (rtx op, enum machine_mode mode)
1937 {
1938   return ((GET_CODE (op) == MEM)
1939           && offsettable_address_p (reload_completed || reload_in_progress,
1940                                     mode, XEXP (op, 0)));
1941 }
1942
1943 /* Return 1 if the operand is either an easy FP constant (see above) or
1944    memory.  */
1945
1946 int
1947 mem_or_easy_const_operand (rtx op, enum machine_mode mode)
1948 {
1949   return memory_operand (op, mode) || easy_fp_constant (op, mode);
1950 }
1951
1952 /* Return 1 if the operand is either a non-special register or an item
1953    that can be used as the operand of a `mode' add insn.  */
1954
1955 int
1956 add_operand (rtx op, enum machine_mode mode)
1957 {
1958   if (GET_CODE (op) == CONST_INT)
1959     return (CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
1960             || CONST_OK_FOR_LETTER_P (INTVAL (op), 'L'));
1961
1962   return gpc_reg_operand (op, mode);
1963 }
1964
1965 /* Return 1 if OP is a constant but not a valid add_operand.  */
1966
1967 int
1968 non_add_cint_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1969 {
1970   return (GET_CODE (op) == CONST_INT
1971           && !CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
1972           && !CONST_OK_FOR_LETTER_P (INTVAL (op), 'L'));
1973 }
1974
1975 /* Return 1 if the operand is a non-special register or a constant that
1976    can be used as the operand of an OR or XOR insn on the RS/6000.  */
1977
1978 int
1979 logical_operand (rtx op, enum machine_mode mode)
1980 {
1981   HOST_WIDE_INT opl, oph;
1982
1983   if (gpc_reg_operand (op, mode))
1984     return 1;
1985
1986   if (GET_CODE (op) == CONST_INT)
1987     {
1988       opl = INTVAL (op) & GET_MODE_MASK (mode);
1989
1990 #if HOST_BITS_PER_WIDE_INT <= 32
1991       if (GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT && opl < 0)
1992         return 0;
1993 #endif
1994     }
1995   else if (GET_CODE (op) == CONST_DOUBLE)
1996     {
1997       if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
1998         abort ();
1999
2000       opl = CONST_DOUBLE_LOW (op);
2001       oph = CONST_DOUBLE_HIGH (op);
2002       if (oph != 0)
2003         return 0;
2004     }
2005   else
2006     return 0;
2007
2008   return ((opl & ~ (unsigned HOST_WIDE_INT) 0xffff) == 0
2009           || (opl & ~ (unsigned HOST_WIDE_INT) 0xffff0000) == 0);
2010 }
2011
2012 /* Return 1 if C is a constant that is not a logical operand (as
2013    above), but could be split into one.  */
2014
2015 int
2016 non_logical_cint_operand (rtx op, enum machine_mode mode)
2017 {
2018   return ((GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE)
2019           && ! logical_operand (op, mode)
2020           && reg_or_logical_cint_operand (op, mode));
2021 }
2022
2023 /* Return 1 if C is a constant that can be encoded in a 32-bit mask on the
2024    RS/6000.  It is if there are no more than two 1->0 or 0->1 transitions.
2025    Reject all ones and all zeros, since these should have been optimized
2026    away and confuse the making of MB and ME.  */
2027
2028 int
2029 mask_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2030 {
2031   HOST_WIDE_INT c, lsb;
2032
2033   if (GET_CODE (op) != CONST_INT)
2034     return 0;
2035
2036   c = INTVAL (op);
2037
2038   /* Fail in 64-bit mode if the mask wraps around because the upper
2039      32-bits of the mask will all be 1s, contrary to GCC's internal view.  */
2040   if (TARGET_POWERPC64 && (c & 0x80000001) == 0x80000001)
2041     return 0;
2042
2043   /* We don't change the number of transitions by inverting,
2044      so make sure we start with the LS bit zero.  */
2045   if (c & 1)
2046     c = ~c;
2047
2048   /* Reject all zeros or all ones.  */
2049   if (c == 0)
2050     return 0;
2051
2052   /* Find the first transition.  */
2053   lsb = c & -c;
2054
2055   /* Invert to look for a second transition.  */
2056   c = ~c;
2057
2058   /* Erase first transition.  */
2059   c &= -lsb;
2060
2061   /* Find the second transition (if any).  */
2062   lsb = c & -c;
2063
2064   /* Match if all the bits above are 1's (or c is zero).  */
2065   return c == -lsb;
2066 }
2067
2068 /* Return 1 for the PowerPC64 rlwinm corner case.  */
2069
2070 int
2071 mask_operand_wrap (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2072 {
2073   HOST_WIDE_INT c, lsb;
2074
2075   if (GET_CODE (op) != CONST_INT)
2076     return 0;
2077
2078   c = INTVAL (op);
2079
2080   if ((c & 0x80000001) != 0x80000001)
2081     return 0;
2082
2083   c = ~c;
2084   if (c == 0)
2085     return 0;
2086
2087   lsb = c & -c;
2088   c = ~c;
2089   c &= -lsb;
2090   lsb = c & -c;
2091   return c == -lsb;
2092 }
2093
2094 /* Return 1 if the operand is a constant that is a PowerPC64 mask.
2095    It is if there are no more than one 1->0 or 0->1 transitions.
2096    Reject all zeros, since zero should have been optimized away and
2097    confuses the making of MB and ME.  */
2098
2099 int
2100 mask64_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2101 {
2102   if (GET_CODE (op) == CONST_INT)
2103     {
2104       HOST_WIDE_INT c, lsb;
2105
2106       c = INTVAL (op);
2107
2108       /* Reject all zeros.  */
2109       if (c == 0)
2110         return 0;
2111
2112       /* We don't change the number of transitions by inverting,
2113          so make sure we start with the LS bit zero.  */
2114       if (c & 1)
2115         c = ~c;
2116
2117       /* Find the transition, and check that all bits above are 1's.  */
2118       lsb = c & -c;
2119
2120       /* Match if all the bits above are 1's (or c is zero).  */
2121       return c == -lsb;
2122     }
2123   return 0;
2124 }
2125
2126 /* Like mask64_operand, but allow up to three transitions.  This
2127    predicate is used by insn patterns that generate two rldicl or
2128    rldicr machine insns.  */
2129
2130 int
2131 mask64_2_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2132 {
2133   if (GET_CODE (op) == CONST_INT)
2134     {
2135       HOST_WIDE_INT c, lsb;
2136
2137       c = INTVAL (op);
2138
2139       /* Disallow all zeros.  */
2140       if (c == 0)
2141         return 0;
2142
2143       /* We don't change the number of transitions by inverting,
2144          so make sure we start with the LS bit zero.  */
2145       if (c & 1)
2146         c = ~c;
2147
2148       /* Find the first transition.  */
2149       lsb = c & -c;
2150
2151       /* Invert to look for a second transition.  */
2152       c = ~c;
2153
2154       /* Erase first transition.  */
2155       c &= -lsb;
2156
2157       /* Find the second transition.  */
2158       lsb = c & -c;
2159
2160       /* Invert to look for a third transition.  */
2161       c = ~c;
2162
2163       /* Erase second transition.  */
2164       c &= -lsb;
2165
2166       /* Find the third transition (if any).  */
2167       lsb = c & -c;
2168
2169       /* Match if all the bits above are 1's (or c is zero).  */
2170       return c == -lsb;
2171     }
2172   return 0;
2173 }
2174
2175 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
2176    implement ANDing by the mask IN.  */
2177 void
2178 build_mask64_2_operands (rtx in, rtx *out)
2179 {
2180 #if HOST_BITS_PER_WIDE_INT >= 64
2181   unsigned HOST_WIDE_INT c, lsb, m1, m2;
2182   int shift;
2183
2184   if (GET_CODE (in) != CONST_INT)
2185     abort ();
2186
2187   c = INTVAL (in);
2188   if (c & 1)
2189     {
2190       /* Assume c initially something like 0x00fff000000fffff.  The idea
2191          is to rotate the word so that the middle ^^^^^^ group of zeros
2192          is at the MS end and can be cleared with an rldicl mask.  We then
2193          rotate back and clear off the MS    ^^ group of zeros with a
2194          second rldicl.  */
2195       c = ~c;                   /*   c == 0xff000ffffff00000 */
2196       lsb = c & -c;             /* lsb == 0x0000000000100000 */
2197       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
2198       c = ~c;                   /*   c == 0x00fff000000fffff */
2199       c &= -lsb;                /*   c == 0x00fff00000000000 */
2200       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2201       c = ~c;                   /*   c == 0xff000fffffffffff */
2202       c &= -lsb;                /*   c == 0xff00000000000000 */
2203       shift = 0;
2204       while ((lsb >>= 1) != 0)
2205         shift++;                /* shift == 44 on exit from loop */
2206       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
2207       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
2208       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
2209     }
2210   else
2211     {
2212       /* Assume c initially something like 0xff000f0000000000.  The idea
2213          is to rotate the word so that the     ^^^  middle group of zeros
2214          is at the LS end and can be cleared with an rldicr mask.  We then
2215          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
2216          a second rldicr.  */
2217       lsb = c & -c;             /* lsb == 0x0000010000000000 */
2218       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
2219       c = ~c;                   /*   c == 0x00fff0ffffffffff */
2220       c &= -lsb;                /*   c == 0x00fff00000000000 */
2221       lsb = c & -c;             /* lsb == 0x0000100000000000 */
2222       c = ~c;                   /*   c == 0xff000fffffffffff */
2223       c &= -lsb;                /*   c == 0xff00000000000000 */
2224       shift = 0;
2225       while ((lsb >>= 1) != 0)
2226         shift++;                /* shift == 44 on exit from loop */
2227       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
2228       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
2229       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
2230     }
2231
2232   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
2233      masks will be all 1's.  We are guaranteed more than one transition.  */
2234   out[0] = GEN_INT (64 - shift);
2235   out[1] = GEN_INT (m1);
2236   out[2] = GEN_INT (shift);
2237   out[3] = GEN_INT (m2);
2238 #else
2239   (void)in;
2240   (void)out;
2241   abort ();
2242 #endif
2243 }
2244
2245 /* Return 1 if the operand is either a non-special register or a constant
2246    that can be used as the operand of a PowerPC64 logical AND insn.  */
2247
2248 int
2249 and64_operand (rtx op, enum machine_mode mode)
2250 {
2251   if (fixed_regs[CR0_REGNO])    /* CR0 not available, don't do andi./andis.  */
2252     return (gpc_reg_operand (op, mode) || mask64_operand (op, mode));
2253
2254   return (logical_operand (op, mode) || mask64_operand (op, mode));
2255 }
2256
2257 /* Like the above, but also match constants that can be implemented
2258    with two rldicl or rldicr insns.  */
2259
2260 int
2261 and64_2_operand (rtx op, enum machine_mode mode)
2262 {
2263   if (fixed_regs[CR0_REGNO])    /* CR0 not available, don't do andi./andis.  */
2264     return gpc_reg_operand (op, mode) || mask64_2_operand (op, mode);
2265
2266   return logical_operand (op, mode) || mask64_2_operand (op, mode);
2267 }
2268
2269 /* Return 1 if the operand is either a non-special register or a
2270    constant that can be used as the operand of an RS/6000 logical AND insn.  */
2271
2272 int
2273 and_operand (rtx op, enum machine_mode mode)
2274 {
2275   if (fixed_regs[CR0_REGNO])    /* CR0 not available, don't do andi./andis.  */
2276     return (gpc_reg_operand (op, mode) || mask_operand (op, mode));
2277
2278   return (logical_operand (op, mode) || mask_operand (op, mode));
2279 }
2280
2281 /* Return 1 if the operand is a general register or memory operand.  */
2282
2283 int
2284 reg_or_mem_operand (rtx op, enum machine_mode mode)
2285 {
2286   return (gpc_reg_operand (op, mode)
2287           || memory_operand (op, mode)
2288           || macho_lo_sum_memory_operand (op, mode)
2289           || volatile_mem_operand (op, mode));
2290 }
2291
2292 /* Return 1 if the operand is a general register or memory operand without
2293    pre_inc or pre_dec which produces invalid form of PowerPC lwa
2294    instruction.  */
2295
2296 int
2297 lwa_operand (rtx op, enum machine_mode mode)
2298 {
2299   rtx inner = op;
2300
2301   if (reload_completed && GET_CODE (inner) == SUBREG)
2302     inner = SUBREG_REG (inner);
2303     
2304   return gpc_reg_operand (inner, mode)
2305     || (memory_operand (inner, mode)
2306         && GET_CODE (XEXP (inner, 0)) != PRE_INC
2307         && GET_CODE (XEXP (inner, 0)) != PRE_DEC
2308         && (GET_CODE (XEXP (inner, 0)) != PLUS
2309             || GET_CODE (XEXP (XEXP (inner, 0), 1)) != CONST_INT
2310             || INTVAL (XEXP (XEXP (inner, 0), 1)) % 4 == 0));
2311 }
2312
2313 /* Return 1 if the operand, used inside a MEM, is a SYMBOL_REF.  */
2314
2315 int
2316 symbol_ref_operand (rtx op, enum machine_mode mode)
2317 {
2318   if (mode != VOIDmode && GET_MODE (op) != mode)
2319     return 0;
2320
2321   return (GET_CODE (op) == SYMBOL_REF
2322           && (DEFAULT_ABI != ABI_AIX || SYMBOL_REF_FUNCTION_P (op)));
2323 }
2324
2325 /* Return 1 if the operand, used inside a MEM, is a valid first argument
2326    to CALL.  This is a SYMBOL_REF, a pseudo-register, LR or CTR.  */
2327
2328 int
2329 call_operand (rtx op, enum machine_mode mode)
2330 {
2331   if (mode != VOIDmode && GET_MODE (op) != mode)
2332     return 0;
2333
2334   return (GET_CODE (op) == SYMBOL_REF
2335           || (GET_CODE (op) == REG
2336               && (REGNO (op) == LINK_REGISTER_REGNUM
2337                   || REGNO (op) == COUNT_REGISTER_REGNUM
2338                   || REGNO (op) >= FIRST_PSEUDO_REGISTER)));
2339 }
2340
2341 /* Return 1 if the operand is a SYMBOL_REF for a function known to be in
2342    this file.  */
2343
2344 int
2345 current_file_function_operand (rtx op, 
2346                               enum machine_mode mode ATTRIBUTE_UNUSED)
2347 {
2348   return (GET_CODE (op) == SYMBOL_REF
2349           && (DEFAULT_ABI != ABI_AIX || SYMBOL_REF_FUNCTION_P (op))
2350           && (SYMBOL_REF_LOCAL_P (op)
2351               || (op == XEXP (DECL_RTL (current_function_decl), 0))));
2352 }
2353
2354 /* Return 1 if this operand is a valid input for a move insn.  */
2355
2356 int
2357 input_operand (rtx op, enum machine_mode mode)
2358 {
2359   /* Memory is always valid.  */
2360   if (memory_operand (op, mode))
2361     return 1;
2362
2363   /* Only a tiny bit of handling for CONSTANT_P_RTX is necessary.  */
2364   if (GET_CODE (op) == CONSTANT_P_RTX)
2365     return 1;
2366
2367   /* For floating-point, easy constants are valid.  */
2368   if (GET_MODE_CLASS (mode) == MODE_FLOAT
2369       && CONSTANT_P (op)
2370       && easy_fp_constant (op, mode))
2371     return 1;
2372
2373   /* Allow any integer constant.  */
2374   if (GET_MODE_CLASS (mode) == MODE_INT
2375       && (GET_CODE (op) == CONST_INT
2376           || GET_CODE (op) == CONST_DOUBLE))
2377     return 1;
2378
2379   /* Allow easy vector constants.  */
2380   if (GET_CODE (op) == CONST_VECTOR
2381       && easy_vector_constant (op, mode))
2382     return 1;
2383
2384   /* For floating-point or multi-word mode, the only remaining valid type
2385      is a register.  */
2386   if (GET_MODE_CLASS (mode) == MODE_FLOAT
2387       || GET_MODE_SIZE (mode) > UNITS_PER_WORD)
2388     return register_operand (op, mode);
2389
2390   /* The only cases left are integral modes one word or smaller (we
2391      do not get called for MODE_CC values).  These can be in any
2392      register.  */
2393   if (register_operand (op, mode))
2394     return 1;
2395
2396   /* A SYMBOL_REF referring to the TOC is valid.  */
2397   if (legitimate_constant_pool_address_p (op))
2398     return 1;
2399
2400   /* A constant pool expression (relative to the TOC) is valid */
2401   if (toc_relative_expr_p (op))
2402     return 1;
2403
2404   /* V.4 allows SYMBOL_REFs and CONSTs that are in the small data region
2405      to be valid.  */
2406   if (DEFAULT_ABI == ABI_V4
2407       && (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == CONST)
2408       && small_data_operand (op, Pmode))
2409     return 1;
2410
2411   return 0;
2412 }
2413
2414
2415 /* Darwin, AIX increases natural record alignment to doubleword if the first
2416    field is an FP double while the FP fields remain word aligned.  */
2417
2418 unsigned int
2419 rs6000_special_round_type_align (tree type, int computed, int specified)
2420 {
2421   tree field = TYPE_FIELDS (type);
2422
2423   /* Skip all the static variables only if ABI is greater than
2424      1 or equal to 0.  */
2425   while (field != NULL && TREE_CODE (field) == VAR_DECL)
2426     field = TREE_CHAIN (field);
2427
2428   if (field == NULL || field == type || DECL_MODE (field) != DFmode)
2429     return MAX (computed, specified);
2430
2431   return MAX (MAX (computed, specified), 64);
2432 }
2433
2434 /* Return 1 for an operand in small memory on V.4/eabi.  */
2435
2436 int
2437 small_data_operand (rtx op ATTRIBUTE_UNUSED, 
2438                     enum machine_mode mode ATTRIBUTE_UNUSED)
2439 {
2440 #if TARGET_ELF
2441   rtx sym_ref;
2442
2443   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
2444     return 0;
2445
2446   if (DEFAULT_ABI != ABI_V4)
2447     return 0;
2448
2449   if (GET_CODE (op) == SYMBOL_REF)
2450     sym_ref = op;
2451
2452   else if (GET_CODE (op) != CONST
2453            || GET_CODE (XEXP (op, 0)) != PLUS
2454            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
2455            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
2456     return 0;
2457
2458   else
2459     {
2460       rtx sum = XEXP (op, 0);
2461       HOST_WIDE_INT summand;
2462
2463       /* We have to be careful here, because it is the referenced address
2464         that must be 32k from _SDA_BASE_, not just the symbol.  */
2465       summand = INTVAL (XEXP (sum, 1));
2466       if (summand < 0 || (unsigned HOST_WIDE_INT) summand > g_switch_value)
2467        return 0;
2468
2469       sym_ref = XEXP (sum, 0);
2470     }
2471
2472   return SYMBOL_REF_SMALL_P (sym_ref);
2473 #else
2474   return 0;
2475 #endif
2476 }
2477
2478 /* Return true, if operand is a memory operand and has a
2479    displacement divisible by 4.  */
2480
2481 int
2482 word_offset_memref_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
2483 {
2484   rtx addr;
2485   int off = 0;
2486
2487   if (!memory_operand (op, mode))
2488     return 0;
2489
2490   addr = XEXP (op, 0);
2491   if (GET_CODE (addr) == PLUS
2492       && GET_CODE (XEXP (addr, 0)) == REG
2493       && GET_CODE (XEXP (addr, 1)) == CONST_INT)
2494     off = INTVAL (XEXP (addr, 1));
2495
2496   return (off % 4) == 0;
2497 }
2498
2499 /* Return true if either operand is a general purpose register.  */
2500
2501 bool
2502 gpr_or_gpr_p (rtx op0, rtx op1)
2503 {
2504   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
2505           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
2506 }
2507
2508 \f
2509 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address.  */
2510
2511 static int 
2512 constant_pool_expr_1 (rtx op, int *have_sym, int *have_toc) 
2513 {
2514   switch (GET_CODE(op)) 
2515     {
2516     case SYMBOL_REF:
2517       if (RS6000_SYMBOL_REF_TLS_P (op))
2518         return 0;
2519       else if (CONSTANT_POOL_ADDRESS_P (op))
2520         {
2521           if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (op), Pmode))
2522             {
2523               *have_sym = 1;
2524               return 1;
2525             }
2526           else
2527             return 0;
2528         }
2529       else if (! strcmp (XSTR (op, 0), toc_label_name))
2530         {
2531           *have_toc = 1;
2532           return 1;
2533         }
2534       else
2535         return 0;
2536     case PLUS:
2537     case MINUS:
2538       return (constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc)
2539               && constant_pool_expr_1 (XEXP (op, 1), have_sym, have_toc));
2540     case CONST:
2541       return constant_pool_expr_1 (XEXP (op, 0), have_sym, have_toc);
2542     case CONST_INT:
2543       return 1;
2544     default:
2545       return 0;
2546     }
2547 }
2548
2549 static bool
2550 constant_pool_expr_p (rtx op)
2551 {
2552   int have_sym = 0;
2553   int have_toc = 0;
2554   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_sym;
2555 }
2556
2557 static bool
2558 toc_relative_expr_p (rtx op)
2559 {
2560   int have_sym = 0;
2561   int have_toc = 0;
2562   return constant_pool_expr_1 (op, &have_sym, &have_toc) && have_toc;
2563 }
2564
2565 /* SPE offset addressing is limited to 5-bits worth of double words.  */
2566 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
2567
2568 bool
2569 legitimate_constant_pool_address_p (rtx x)
2570 {
2571   return (TARGET_TOC
2572           && GET_CODE (x) == PLUS
2573           && GET_CODE (XEXP (x, 0)) == REG
2574           && (TARGET_MINIMAL_TOC || REGNO (XEXP (x, 0)) == TOC_REGISTER)
2575           && constant_pool_expr_p (XEXP (x, 1)));
2576 }
2577
2578 static bool
2579 legitimate_small_data_p (enum machine_mode mode, rtx x)
2580 {
2581   return (DEFAULT_ABI == ABI_V4
2582           && !flag_pic && !TARGET_TOC
2583           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
2584           && small_data_operand (x, mode));
2585 }
2586
2587 static bool
2588 legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
2589 {
2590   unsigned HOST_WIDE_INT offset, extra;
2591
2592   if (GET_CODE (x) != PLUS)
2593     return false;
2594   if (GET_CODE (XEXP (x, 0)) != REG)
2595     return false;
2596   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
2597     return false;
2598   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2599     return false;
2600
2601   offset = INTVAL (XEXP (x, 1));
2602   extra = 0;
2603   switch (mode)
2604     {
2605     case V16QImode:
2606     case V8HImode:
2607     case V4SFmode:
2608     case V4SImode:
2609       /* AltiVec vector modes.  Only reg+reg addressing is valid here,
2610          which leaves the only valid constant offset of zero, which by
2611          canonicalization rules is also invalid.  */
2612       return false;
2613
2614     case V4HImode:
2615     case V2SImode:
2616     case V1DImode:
2617     case V2SFmode:
2618       /* SPE vector modes.  */
2619       return SPE_CONST_OFFSET_OK (offset);
2620
2621     case DFmode:
2622     case DImode:
2623       if (mode == DFmode || !TARGET_POWERPC64)
2624         extra = 4;
2625       else if (offset & 3)
2626         return false;
2627       break;
2628
2629     case TFmode:
2630     case TImode:
2631       if (mode == TFmode || !TARGET_POWERPC64)
2632         extra = 12;
2633       else if (offset & 3)
2634         return false;
2635       else
2636         extra = 8;
2637       break;
2638
2639     default:
2640       break;
2641     }
2642
2643   offset += 0x8000;
2644   return (offset < 0x10000) && (offset + extra < 0x10000);
2645 }
2646
2647 static bool
2648 legitimate_indexed_address_p (rtx x, int strict)
2649 {
2650   rtx op0, op1;
2651
2652   if (GET_CODE (x) != PLUS)
2653     return false;
2654   op0 = XEXP (x, 0);
2655   op1 = XEXP (x, 1);
2656
2657   if (!REG_P (op0) || !REG_P (op1))
2658     return false;
2659
2660   return ((INT_REG_OK_FOR_BASE_P (op0, strict)
2661            && INT_REG_OK_FOR_INDEX_P (op1, strict))
2662           || (INT_REG_OK_FOR_BASE_P (op1, strict)
2663               && INT_REG_OK_FOR_INDEX_P (op0, strict)));
2664 }
2665
2666 static inline bool
2667 legitimate_indirect_address_p (rtx x, int strict)
2668 {
2669   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
2670 }
2671
2672 static bool
2673 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
2674 {
2675     if (!TARGET_MACHO || !flag_pic
2676         || mode != SImode || GET_CODE(x) != MEM)
2677       return false;
2678     x = XEXP (x, 0);
2679
2680   if (GET_CODE (x) != LO_SUM)
2681     return false;
2682   if (GET_CODE (XEXP (x, 0)) != REG)
2683     return false;
2684   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
2685     return false;
2686   x = XEXP (x, 1);
2687
2688   return CONSTANT_P (x);
2689 }
2690
2691 static bool
2692 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
2693 {
2694   if (GET_CODE (x) != LO_SUM)
2695     return false;
2696   if (GET_CODE (XEXP (x, 0)) != REG)
2697     return false;
2698   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
2699     return false;
2700   x = XEXP (x, 1);
2701
2702   if (TARGET_ELF || TARGET_MACHO)
2703     {
2704       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
2705         return false;
2706       if (TARGET_TOC)
2707         return false;
2708       if (GET_MODE_NUNITS (mode) != 1)
2709         return false;
2710       if (GET_MODE_BITSIZE (mode) > 32
2711           && !(TARGET_HARD_FLOAT && TARGET_FPRS && mode == DFmode))
2712         return false;
2713
2714       return CONSTANT_P (x);
2715     }
2716
2717   return false;
2718 }
2719
2720
2721 /* Try machine-dependent ways of modifying an illegitimate address
2722    to be legitimate.  If we find one, return the new, valid address.
2723    This is used from only one place: `memory_address' in explow.c.
2724
2725    OLDX is the address as it was before break_out_memory_refs was
2726    called.  In some cases it is useful to look at this to decide what
2727    needs to be done.
2728
2729    MODE is passed so that this function can use GO_IF_LEGITIMATE_ADDRESS.
2730
2731    It is always safe for this function to do nothing.  It exists to
2732    recognize opportunities to optimize the output.
2733
2734    On RS/6000, first check for the sum of a register with a constant
2735    integer that is out of range.  If so, generate code to add the
2736    constant with the low-order 16 bits masked to the register and force
2737    this result into another register (this can be done with `cau').
2738    Then generate an address of REG+(CONST&0xffff), allowing for the
2739    possibility of bit 16 being a one.
2740
2741    Then check for the sum of a register and something not constant, try to
2742    load the other things into a register and return the sum.  */
2743
2744 rtx
2745 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
2746                            enum machine_mode mode)
2747 {
2748   if (GET_CODE (x) == SYMBOL_REF)
2749     {
2750       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
2751       if (model != 0)
2752         return rs6000_legitimize_tls_address (x, model);
2753     }
2754
2755   if (GET_CODE (x) == PLUS 
2756       && GET_CODE (XEXP (x, 0)) == REG
2757       && GET_CODE (XEXP (x, 1)) == CONST_INT
2758       && (unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000) >= 0x10000)
2759     { 
2760       HOST_WIDE_INT high_int, low_int;
2761       rtx sum;
2762       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
2763       high_int = INTVAL (XEXP (x, 1)) - low_int;
2764       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
2765                                          GEN_INT (high_int)), 0);
2766       return gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int));
2767     }
2768   else if (GET_CODE (x) == PLUS 
2769            && GET_CODE (XEXP (x, 0)) == REG
2770            && GET_CODE (XEXP (x, 1)) != CONST_INT
2771            && GET_MODE_NUNITS (mode) == 1
2772            && ((TARGET_HARD_FLOAT && TARGET_FPRS)
2773                || TARGET_POWERPC64
2774                || (mode != DFmode && mode != TFmode))
2775            && (TARGET_POWERPC64 || mode != DImode)
2776            && mode != TImode)
2777     {
2778       return gen_rtx_PLUS (Pmode, XEXP (x, 0),
2779                            force_reg (Pmode, force_operand (XEXP (x, 1), 0)));
2780     }
2781   else if (ALTIVEC_VECTOR_MODE (mode))
2782     {
2783       rtx reg;
2784
2785       /* Make sure both operands are registers.  */
2786       if (GET_CODE (x) == PLUS)
2787         return gen_rtx_PLUS (Pmode, force_reg (Pmode, XEXP (x, 0)),
2788                              force_reg (Pmode, XEXP (x, 1)));
2789
2790       reg = force_reg (Pmode, x);
2791       return reg;
2792     }
2793   else if (SPE_VECTOR_MODE (mode))
2794     {
2795       /* We accept [reg + reg] and [reg + OFFSET].  */
2796
2797       if (GET_CODE (x) == PLUS)
2798       {
2799         rtx op1 = XEXP (x, 0);
2800         rtx op2 = XEXP (x, 1);
2801
2802         op1 = force_reg (Pmode, op1);
2803
2804         if (GET_CODE (op2) != REG
2805             && (GET_CODE (op2) != CONST_INT
2806                 || !SPE_CONST_OFFSET_OK (INTVAL (op2))))
2807           op2 = force_reg (Pmode, op2);
2808
2809         return gen_rtx_PLUS (Pmode, op1, op2);
2810       }
2811
2812       return force_reg (Pmode, x);
2813     }
2814   else if (TARGET_ELF
2815            && TARGET_32BIT
2816            && TARGET_NO_TOC
2817            && ! flag_pic
2818            && GET_CODE (x) != CONST_INT
2819            && GET_CODE (x) != CONST_DOUBLE 
2820            && CONSTANT_P (x)
2821            && GET_MODE_NUNITS (mode) == 1
2822            && (GET_MODE_BITSIZE (mode) <= 32
2823                || ((TARGET_HARD_FLOAT && TARGET_FPRS) && mode == DFmode)))
2824     {
2825       rtx reg = gen_reg_rtx (Pmode);
2826       emit_insn (gen_elf_high (reg, x));
2827       return gen_rtx_LO_SUM (Pmode, reg, x);
2828     }
2829   else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC
2830            && ! flag_pic
2831 #if TARGET_MACHO
2832            && ! MACHO_DYNAMIC_NO_PIC_P
2833 #endif
2834            && GET_CODE (x) != CONST_INT
2835            && GET_CODE (x) != CONST_DOUBLE 
2836            && CONSTANT_P (x)
2837            && ((TARGET_HARD_FLOAT && TARGET_FPRS) || mode != DFmode)
2838            && mode != DImode 
2839            && mode != TImode)
2840     {
2841       rtx reg = gen_reg_rtx (Pmode);
2842       emit_insn (gen_macho_high (reg, x));
2843       return gen_rtx_LO_SUM (Pmode, reg, x);
2844     }
2845   else if (TARGET_TOC 
2846            && constant_pool_expr_p (x)
2847            && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), Pmode))
2848     {
2849       return create_TOC_reference (x);
2850     }
2851   else
2852     return NULL_RTX;
2853 }
2854
2855 /* This is called from dwarf2out.c via ASM_OUTPUT_DWARF_DTPREL.
2856    We need to emit DTP-relative relocations.  */
2857
2858 void
2859 rs6000_output_dwarf_dtprel (FILE *file, int size, rtx x)
2860 {
2861   switch (size)
2862     {
2863     case 4:
2864       fputs ("\t.long\t", file);
2865       break;
2866     case 8:
2867       fputs (DOUBLE_INT_ASM_OP, file);
2868       break;
2869     default:
2870       abort ();
2871     }
2872   output_addr_const (file, x);
2873   fputs ("@dtprel+0x8000", file);
2874 }
2875
2876 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
2877
2878 static GTY(()) rtx rs6000_tls_symbol;
2879 static rtx
2880 rs6000_tls_get_addr (void)
2881 {
2882   if (!rs6000_tls_symbol)
2883     rs6000_tls_symbol = init_one_libfunc ("__tls_get_addr");
2884
2885   return rs6000_tls_symbol;
2886 }
2887
2888 /* Construct the SYMBOL_REF for TLS GOT references.  */
2889
2890 static GTY(()) rtx rs6000_got_symbol;
2891 static rtx
2892 rs6000_got_sym (void)
2893 {
2894   if (!rs6000_got_symbol)
2895     {
2896       rs6000_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
2897       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_LOCAL;
2898       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_EXTERNAL;
2899     }     
2900
2901   return rs6000_got_symbol;
2902 }
2903
2904 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
2905    this (thread-local) address.  */
2906
2907 static rtx
2908 rs6000_legitimize_tls_address (rtx addr, enum tls_model model)
2909 {
2910   rtx dest, insn;
2911
2912   dest = gen_reg_rtx (Pmode);
2913   if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 16)
2914     {
2915       rtx tlsreg;
2916
2917       if (TARGET_64BIT)
2918         {
2919           tlsreg = gen_rtx_REG (Pmode, 13);
2920           insn = gen_tls_tprel_64 (dest, tlsreg, addr);
2921         }
2922       else
2923         {
2924           tlsreg = gen_rtx_REG (Pmode, 2);
2925           insn = gen_tls_tprel_32 (dest, tlsreg, addr);
2926         }
2927       emit_insn (insn);
2928     }
2929   else if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 32)
2930     {
2931       rtx tlsreg, tmp;
2932
2933       tmp = gen_reg_rtx (Pmode);
2934       if (TARGET_64BIT)
2935         {
2936           tlsreg = gen_rtx_REG (Pmode, 13);
2937           insn = gen_tls_tprel_ha_64 (tmp, tlsreg, addr);
2938         }
2939       else
2940         {
2941           tlsreg = gen_rtx_REG (Pmode, 2);
2942           insn = gen_tls_tprel_ha_32 (tmp, tlsreg, addr);
2943         }
2944       emit_insn (insn);
2945       if (TARGET_64BIT)
2946         insn = gen_tls_tprel_lo_64 (dest, tmp, addr);
2947       else
2948         insn = gen_tls_tprel_lo_32 (dest, tmp, addr);
2949       emit_insn (insn);
2950     }
2951   else
2952     {
2953       rtx r3, got, tga, tmp1, tmp2, eqv;
2954
2955       if (TARGET_64BIT)
2956         got = gen_rtx_REG (Pmode, TOC_REGISTER);
2957       else
2958         {
2959           if (flag_pic == 1)
2960             got = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
2961           else
2962             {
2963               rtx gsym = rs6000_got_sym ();
2964               got = gen_reg_rtx (Pmode);
2965               if (flag_pic == 0)
2966                 rs6000_emit_move (got, gsym, Pmode);
2967               else
2968                 {
2969                   char buf[30];
2970                   static int tls_got_labelno = 0;
2971                   rtx tempLR, lab, tmp3, mem;
2972                   rtx first, last;
2973
2974                   ASM_GENERATE_INTERNAL_LABEL (buf, "LTLS", tls_got_labelno++);
2975                   lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
2976                   tempLR = gen_reg_rtx (Pmode);
2977                   tmp1 = gen_reg_rtx (Pmode);
2978                   tmp2 = gen_reg_rtx (Pmode);
2979                   tmp3 = gen_reg_rtx (Pmode);
2980                   mem = gen_rtx_MEM (Pmode, tmp1);
2981                   RTX_UNCHANGING_P (mem) = 1;
2982
2983                   first = emit_insn (gen_load_toc_v4_PIC_1b (tempLR, lab,
2984                                                              gsym));
2985                   emit_move_insn (tmp1, tempLR);
2986                   emit_move_insn (tmp2, mem);
2987                   emit_insn (gen_addsi3 (tmp3, tmp1, tmp2));
2988                   last = emit_move_insn (got, tmp3);
2989                   REG_NOTES (last) = gen_rtx_EXPR_LIST (REG_EQUAL, gsym,
2990                                                         REG_NOTES (last));
2991                   REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
2992                                                          REG_NOTES (first));
2993                   REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first,
2994                                                         REG_NOTES (last));
2995                 }
2996             }
2997         }
2998
2999       if (model == TLS_MODEL_GLOBAL_DYNAMIC)
3000         {
3001           r3 = gen_rtx_REG (Pmode, 3);
3002           if (TARGET_64BIT)
3003             insn = gen_tls_gd_64 (r3, got, addr);
3004           else
3005             insn = gen_tls_gd_32 (r3, got, addr);
3006           start_sequence ();
3007           emit_insn (insn);
3008           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
3009           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
3010           insn = emit_call_insn (insn);
3011           CONST_OR_PURE_CALL_P (insn) = 1;
3012           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
3013           insn = get_insns ();
3014           end_sequence ();
3015           emit_libcall_block (insn, dest, r3, addr);
3016         }
3017       else if (model == TLS_MODEL_LOCAL_DYNAMIC)
3018         {
3019           r3 = gen_rtx_REG (Pmode, 3);
3020           if (TARGET_64BIT)
3021             insn = gen_tls_ld_64 (r3, got);
3022           else
3023             insn = gen_tls_ld_32 (r3, got);
3024           start_sequence ();
3025           emit_insn (insn);
3026           tga = gen_rtx_MEM (Pmode, rs6000_tls_get_addr ());
3027           insn = gen_call_value (r3, tga, const0_rtx, const0_rtx);
3028           insn = emit_call_insn (insn);
3029           CONST_OR_PURE_CALL_P (insn) = 1;
3030           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r3);
3031           insn = get_insns ();
3032           end_sequence ();
3033           tmp1 = gen_reg_rtx (Pmode);
3034           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
3035                                 UNSPEC_TLSLD);
3036           emit_libcall_block (insn, tmp1, r3, eqv);
3037           if (rs6000_tls_size == 16)
3038             {
3039               if (TARGET_64BIT)
3040                 insn = gen_tls_dtprel_64 (dest, tmp1, addr);
3041               else
3042                 insn = gen_tls_dtprel_32 (dest, tmp1, addr);
3043             }
3044           else if (rs6000_tls_size == 32)
3045             {
3046               tmp2 = gen_reg_rtx (Pmode);
3047               if (TARGET_64BIT)
3048                 insn = gen_tls_dtprel_ha_64 (tmp2, tmp1, addr);
3049               else
3050                 insn = gen_tls_dtprel_ha_32 (tmp2, tmp1, addr);
3051               emit_insn (insn);
3052               if (TARGET_64BIT)
3053                 insn = gen_tls_dtprel_lo_64 (dest, tmp2, addr);
3054               else
3055                 insn = gen_tls_dtprel_lo_32 (dest, tmp2, addr);
3056             }
3057           else
3058             {
3059               tmp2 = gen_reg_rtx (Pmode);
3060               if (TARGET_64BIT)
3061                 insn = gen_tls_got_dtprel_64 (tmp2, got, addr);
3062               else
3063                 insn = gen_tls_got_dtprel_32 (tmp2, got, addr);
3064               emit_insn (insn);
3065               insn = gen_rtx_SET (Pmode, dest,
3066                                   gen_rtx_PLUS (Pmode, tmp2, tmp1));
3067             }
3068           emit_insn (insn);
3069         }
3070       else
3071         {
3072           /* IE, or 64 bit offset LE.  */
3073           tmp2 = gen_reg_rtx (Pmode);
3074           if (TARGET_64BIT)
3075             insn = gen_tls_got_tprel_64 (tmp2, got, addr);
3076           else
3077             insn = gen_tls_got_tprel_32 (tmp2, got, addr);
3078           emit_insn (insn);
3079           if (TARGET_64BIT)
3080             insn = gen_tls_tls_64 (dest, tmp2, addr);
3081           else
3082             insn = gen_tls_tls_32 (dest, tmp2, addr);
3083           emit_insn (insn);
3084         }
3085     }
3086
3087   return dest;
3088 }
3089
3090 /* Return 1 if X is a SYMBOL_REF for a TLS symbol.  This is used in
3091    instruction definitions.  */
3092
3093 int
3094 rs6000_tls_symbol_ref (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED)
3095 {
3096   return RS6000_SYMBOL_REF_TLS_P (x);
3097 }
3098
3099 /* Return 1 if X contains a thread-local symbol.  */
3100
3101 bool
3102 rs6000_tls_referenced_p (rtx x)
3103 {
3104   if (! TARGET_HAVE_TLS)
3105     return false;
3106
3107   return for_each_rtx (&x, &rs6000_tls_symbol_ref_1, 0);
3108 }
3109
3110 /* Return 1 if *X is a thread-local symbol.  This is the same as
3111    rs6000_tls_symbol_ref except for the type of the unused argument.  */
3112
3113 static inline int
3114 rs6000_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
3115 {
3116   return RS6000_SYMBOL_REF_TLS_P (*x);
3117 }
3118
3119 /* The convention appears to be to define this wherever it is used.
3120    With legitimize_reload_address now defined here, REG_MODE_OK_FOR_BASE_P
3121    is now used here.  */
3122 #ifndef REG_MODE_OK_FOR_BASE_P
3123 #define REG_MODE_OK_FOR_BASE_P(REGNO, MODE) REG_OK_FOR_BASE_P (REGNO)
3124 #endif
3125
3126 /* Our implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
3127    replace the input X, or the original X if no replacement is called for.
3128    The output parameter *WIN is 1 if the calling macro should goto WIN,
3129    0 if it should not.
3130
3131    For RS/6000, we wish to handle large displacements off a base
3132    register by splitting the addend across an addiu/addis and the mem insn.
3133    This cuts number of extra insns needed from 3 to 1.
3134
3135    On Darwin, we use this to generate code for floating point constants.
3136    A movsf_low is generated so we wind up with 2 instructions rather than 3.
3137    The Darwin code is inside #if TARGET_MACHO because only then is
3138    machopic_function_base_name() defined.  */
3139 rtx
3140 rs6000_legitimize_reload_address (rtx x, enum machine_mode mode, 
3141         int opnum, int type, int ind_levels ATTRIBUTE_UNUSED, int *win)
3142 {
3143   /* We must recognize output that we have already generated ourselves.  */ 
3144   if (GET_CODE (x) == PLUS
3145       && GET_CODE (XEXP (x, 0)) == PLUS
3146       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
3147       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
3148       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3149     {
3150       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3151                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3152                    opnum, (enum reload_type)type);
3153       *win = 1;
3154       return x;
3155     }
3156
3157 #if TARGET_MACHO
3158   if (DEFAULT_ABI == ABI_DARWIN && flag_pic
3159       && GET_CODE (x) == LO_SUM
3160       && GET_CODE (XEXP (x, 0)) == PLUS
3161       && XEXP (XEXP (x, 0), 0) == pic_offset_table_rtx
3162       && GET_CODE (XEXP (XEXP (x, 0), 1)) == HIGH
3163       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 0)) == CONST
3164       && XEXP (XEXP (XEXP (x, 0), 1), 0) == XEXP (x, 1)
3165       && GET_CODE (XEXP (XEXP (x, 1), 0)) == MINUS
3166       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 0)) == SYMBOL_REF
3167       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 1)) == SYMBOL_REF)
3168     {
3169       /* Result of previous invocation of this function on Darwin
3170          floating point constant.  */
3171       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3172                 BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3173                 opnum, (enum reload_type)type);
3174       *win = 1;
3175       return x;
3176     }
3177 #endif
3178   if (GET_CODE (x) == PLUS
3179       && GET_CODE (XEXP (x, 0)) == REG
3180       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
3181       && REG_MODE_OK_FOR_BASE_P (XEXP (x, 0), mode)
3182       && GET_CODE (XEXP (x, 1)) == CONST_INT
3183       && !SPE_VECTOR_MODE (mode)
3184       && !ALTIVEC_VECTOR_MODE (mode))
3185     {
3186       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
3187       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
3188       HOST_WIDE_INT high
3189         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
3190
3191       /* Check for 32-bit overflow.  */
3192       if (high + low != val)
3193         {
3194           *win = 0;
3195           return x;
3196         }
3197
3198       /* Reload the high part into a base reg; leave the low part
3199          in the mem directly.  */
3200
3201       x = gen_rtx_PLUS (GET_MODE (x),
3202                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
3203                                       GEN_INT (high)),
3204                         GEN_INT (low));
3205
3206       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3207                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
3208                    opnum, (enum reload_type)type);
3209       *win = 1;
3210       return x;
3211     }
3212 #if TARGET_MACHO
3213   if (GET_CODE (x) == SYMBOL_REF
3214       && DEFAULT_ABI == ABI_DARWIN
3215       && !ALTIVEC_VECTOR_MODE (mode)
3216       && (flag_pic || MACHO_DYNAMIC_NO_PIC_P)
3217       /* Don't do this for TFmode, since the result isn't offsettable.  */
3218       && mode != TFmode)
3219     {
3220       if (flag_pic)
3221         {
3222           rtx offset = gen_rtx_CONST (Pmode,
3223                          gen_rtx_MINUS (Pmode, x,
3224                            gen_rtx_SYMBOL_REF (Pmode,
3225                              machopic_function_base_name ())));
3226           x = gen_rtx_LO_SUM (GET_MODE (x),
3227                 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
3228                   gen_rtx_HIGH (Pmode, offset)), offset);
3229         }
3230       else
3231         x = gen_rtx_LO_SUM (GET_MODE (x),
3232               gen_rtx_HIGH (Pmode, x), x);
3233
3234       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
3235                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
3236                    opnum, (enum reload_type)type);
3237       *win = 1;
3238       return x;
3239     }
3240 #endif
3241   if (TARGET_TOC
3242       && constant_pool_expr_p (x)
3243       && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), mode))
3244     {
3245       (x) = create_TOC_reference (x);
3246       *win = 1;
3247       return x;
3248     }
3249   *win = 0;
3250   return x;
3251 }    
3252
3253 /* GO_IF_LEGITIMATE_ADDRESS recognizes an RTL expression
3254    that is a valid memory address for an instruction.
3255    The MODE argument is the machine mode for the MEM expression
3256    that wants to use this address.
3257
3258    On the RS/6000, there are four valid address: a SYMBOL_REF that
3259    refers to a constant pool entry of an address (or the sum of it
3260    plus a constant), a short (16-bit signed) constant plus a register,
3261    the sum of two registers, or a register indirect, possibly with an
3262    auto-increment.  For DFmode and DImode with a constant plus register,
3263    we must ensure that both words are addressable or PowerPC64 with offset
3264    word aligned.
3265
3266    For modes spanning multiple registers (DFmode in 32-bit GPRs,
3267    32-bit DImode, TImode), indexed addressing cannot be used because
3268    adjacent memory cells are accessed by adding word-sized offsets
3269    during assembly output.  */
3270 int
3271 rs6000_legitimate_address (enum machine_mode mode, rtx x, int reg_ok_strict)
3272 {
3273   if (RS6000_SYMBOL_REF_TLS_P (x))
3274     return 0;
3275   if (legitimate_indirect_address_p (x, reg_ok_strict))
3276     return 1;
3277   if ((GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC)
3278       && !ALTIVEC_VECTOR_MODE (mode)
3279       && !SPE_VECTOR_MODE (mode)
3280       && TARGET_UPDATE
3281       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict))
3282     return 1;
3283   if (legitimate_small_data_p (mode, x))
3284     return 1;
3285   if (legitimate_constant_pool_address_p (x))
3286     return 1;
3287   /* If not REG_OK_STRICT (before reload) let pass any stack offset.  */
3288   if (! reg_ok_strict
3289       && GET_CODE (x) == PLUS
3290       && GET_CODE (XEXP (x, 0)) == REG
3291       && (XEXP (x, 0) == virtual_stack_vars_rtx
3292          || XEXP (x, 0) == arg_pointer_rtx)
3293       && GET_CODE (XEXP (x, 1)) == CONST_INT)
3294     return 1;
3295   if (legitimate_offset_address_p (mode, x, reg_ok_strict))
3296     return 1;
3297   if (mode != TImode
3298       && ((TARGET_HARD_FLOAT && TARGET_FPRS)
3299           || TARGET_POWERPC64
3300           || (mode != DFmode && mode != TFmode))
3301       && (TARGET_POWERPC64 || mode != DImode)
3302       && legitimate_indexed_address_p (x, reg_ok_strict))
3303     return 1;
3304   if (legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
3305     return 1;
3306   return 0;
3307 }
3308
3309 /* Go to LABEL if ADDR (a legitimate address expression)
3310    has an effect that depends on the machine mode it is used for.
3311
3312    On the RS/6000 this is true of all integral offsets (since AltiVec
3313    modes don't allow them) or is a pre-increment or decrement.
3314
3315    ??? Except that due to conceptual problems in offsettable_address_p
3316    we can't really report the problems of integral offsets.  So leave
3317    this assuming that the adjustable offset must be valid for the 
3318    sub-words of a TFmode operand, which is what we had before.  */
3319
3320 bool
3321 rs6000_mode_dependent_address (rtx addr)
3322 {
3323   switch (GET_CODE (addr))
3324     {
3325     case PLUS:
3326       if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
3327         {
3328           unsigned HOST_WIDE_INT val = INTVAL (XEXP (addr, 1));
3329           return val + 12 + 0x8000 >= 0x10000;
3330         }
3331       break;
3332
3333     case LO_SUM:
3334       return true;
3335
3336     case PRE_INC:
3337     case PRE_DEC:
3338       return TARGET_UPDATE;
3339
3340     default:
3341       break;
3342     }
3343
3344   return false;
3345 }
3346
3347 /* Return number of consecutive hard regs needed starting at reg REGNO
3348    to hold something of mode MODE.
3349    This is ordinarily the length in words of a value of mode MODE
3350    but can be less for certain modes in special long registers.
3351
3352    For the SPE, GPRs are 64 bits but only 32 bits are visible in
3353    scalar instructions.  The upper 32 bits are only available to the
3354    SIMD instructions.
3355
3356    POWER and PowerPC GPRs hold 32 bits worth;
3357    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
3358
3359 int
3360 rs6000_hard_regno_nregs (int regno, enum machine_mode mode)
3361 {
3362   if (FP_REGNO_P (regno))
3363     return (GET_MODE_SIZE (mode) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD;
3364
3365   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
3366     return (GET_MODE_SIZE (mode) + UNITS_PER_SPE_WORD - 1) / UNITS_PER_SPE_WORD;
3367
3368   if (ALTIVEC_REGNO_P (regno))
3369     return
3370       (GET_MODE_SIZE (mode) + UNITS_PER_ALTIVEC_WORD - 1) / UNITS_PER_ALTIVEC_WORD;
3371
3372   return (GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3373 }
3374 \f
3375 /* Try to output insns to set TARGET equal to the constant C if it can
3376    be done in less than N insns.  Do all computations in MODE.
3377    Returns the place where the output has been placed if it can be
3378    done and the insns have been emitted.  If it would take more than N
3379    insns, zero is returned and no insns and emitted.  */
3380
3381 rtx
3382 rs6000_emit_set_const (rtx dest, enum machine_mode mode, 
3383                        rtx source, int n ATTRIBUTE_UNUSED)
3384 {
3385   rtx result, insn, set;
3386   HOST_WIDE_INT c0, c1;
3387
3388   if (mode == QImode || mode == HImode)
3389     {
3390       if (dest == NULL)
3391         dest = gen_reg_rtx (mode);
3392       emit_insn (gen_rtx_SET (VOIDmode, dest, source));
3393       return dest;
3394     }
3395   else if (mode == SImode)
3396     {
3397       result = no_new_pseudos ? dest : gen_reg_rtx (SImode);
3398
3399       emit_insn (gen_rtx_SET (VOIDmode, result,
3400                               GEN_INT (INTVAL (source)
3401                                        & (~ (HOST_WIDE_INT) 0xffff))));
3402       emit_insn (gen_rtx_SET (VOIDmode, dest,
3403                               gen_rtx_IOR (SImode, result,
3404                                            GEN_INT (INTVAL (source) & 0xffff))));
3405       result = dest;
3406     }
3407   else if (mode == DImode)
3408     {
3409       if (GET_CODE (source) == CONST_INT)
3410         {
3411           c0 = INTVAL (source);
3412           c1 = -(c0 < 0);
3413         }
3414       else if (GET_CODE (source) == CONST_DOUBLE)
3415         {
3416 #if HOST_BITS_PER_WIDE_INT >= 64
3417           c0 = CONST_DOUBLE_LOW (source);
3418           c1 = -(c0 < 0);
3419 #else
3420           c0 = CONST_DOUBLE_LOW (source);
3421           c1 = CONST_DOUBLE_HIGH (source);
3422 #endif
3423         }
3424       else
3425         abort ();
3426
3427       result = rs6000_emit_set_long_const (dest, c0, c1);
3428     }
3429   else
3430     abort ();
3431
3432   insn = get_last_insn ();
3433   set = single_set (insn);
3434   if (! CONSTANT_P (SET_SRC (set)))
3435     set_unique_reg_note (insn, REG_EQUAL, source);
3436
3437   return result;
3438 }
3439
3440 /* Having failed to find a 3 insn sequence in rs6000_emit_set_const,
3441    fall back to a straight forward decomposition.  We do this to avoid
3442    exponential run times encountered when looking for longer sequences
3443    with rs6000_emit_set_const.  */
3444 static rtx
3445 rs6000_emit_set_long_const (rtx dest, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
3446 {
3447   if (!TARGET_POWERPC64)
3448     {
3449       rtx operand1, operand2;
3450
3451       operand1 = operand_subword_force (dest, WORDS_BIG_ENDIAN == 0,
3452                                         DImode);
3453       operand2 = operand_subword_force (dest, WORDS_BIG_ENDIAN != 0,
3454                                         DImode);
3455       emit_move_insn (operand1, GEN_INT (c1));
3456       emit_move_insn (operand2, GEN_INT (c2));
3457     }
3458   else
3459     {
3460       HOST_WIDE_INT ud1, ud2, ud3, ud4;
3461
3462       ud1 = c1 & 0xffff;
3463       ud2 = (c1 & 0xffff0000) >> 16;
3464 #if HOST_BITS_PER_WIDE_INT >= 64
3465       c2 = c1 >> 32;
3466 #endif
3467       ud3 = c2 & 0xffff;
3468       ud4 = (c2 & 0xffff0000) >> 16;
3469
3470       if ((ud4 == 0xffff && ud3 == 0xffff && ud2 == 0xffff && (ud1 & 0x8000)) 
3471           || (ud4 == 0 && ud3 == 0 && ud2 == 0 && ! (ud1 & 0x8000)))
3472         {
3473           if (ud1 & 0x8000)
3474             emit_move_insn (dest, GEN_INT (((ud1 ^ 0x8000) -  0x8000)));
3475           else
3476             emit_move_insn (dest, GEN_INT (ud1));
3477         }
3478
3479       else if ((ud4 == 0xffff && ud3 == 0xffff && (ud2 & 0x8000)) 
3480                || (ud4 == 0 && ud3 == 0 && ! (ud2 & 0x8000)))
3481         {
3482           if (ud2 & 0x8000)
3483             emit_move_insn (dest, GEN_INT (((ud2 << 16) ^ 0x80000000) 
3484                                            - 0x80000000));
3485           else
3486             emit_move_insn (dest, GEN_INT (ud2 << 16));
3487           if (ud1 != 0)
3488             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3489         }
3490       else if ((ud4 == 0xffff && (ud3 & 0x8000)) 
3491                || (ud4 == 0 && ! (ud3 & 0x8000)))
3492         {
3493           if (ud3 & 0x8000)
3494             emit_move_insn (dest, GEN_INT (((ud3 << 16) ^ 0x80000000) 
3495                                            - 0x80000000));
3496           else
3497             emit_move_insn (dest, GEN_INT (ud3 << 16));
3498
3499           if (ud2 != 0)
3500             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud2)));
3501           emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (16)));
3502           if (ud1 != 0)
3503             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3504         }
3505       else 
3506         {
3507           if (ud4 & 0x8000)
3508             emit_move_insn (dest, GEN_INT (((ud4 << 16) ^ 0x80000000) 
3509                                            - 0x80000000));
3510           else
3511             emit_move_insn (dest, GEN_INT (ud4 << 16));
3512
3513           if (ud3 != 0)
3514             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud3)));
3515
3516           emit_move_insn (dest, gen_rtx_ASHIFT (DImode, dest, GEN_INT (32)));
3517           if (ud2 != 0)
3518             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, 
3519                                                GEN_INT (ud2 << 16)));   
3520           if (ud1 != 0)
3521             emit_move_insn (dest, gen_rtx_IOR (DImode, dest, GEN_INT (ud1)));
3522         }
3523     }
3524   return dest;
3525 }
3526
3527 /* Emit a move from SOURCE to DEST in mode MODE.  */
3528 void
3529 rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode)
3530 {
3531   rtx operands[2];
3532   operands[0] = dest;
3533   operands[1] = source;
3534   
3535   /* Sanity checks.  Check that we get CONST_DOUBLE only when we should.  */
3536   if (GET_CODE (operands[1]) == CONST_DOUBLE
3537       && ! FLOAT_MODE_P (mode)
3538       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
3539     {
3540       /* FIXME.  This should never happen.  */
3541       /* Since it seems that it does, do the safe thing and convert
3542          to a CONST_INT.  */
3543       operands[1] = gen_int_mode (CONST_DOUBLE_LOW (operands[1]), mode);
3544     }
3545   if (GET_CODE (operands[1]) == CONST_DOUBLE
3546       && ! FLOAT_MODE_P (mode)
3547       && ((CONST_DOUBLE_HIGH (operands[1]) == 0
3548            && CONST_DOUBLE_LOW (operands[1]) >= 0)
3549           || (CONST_DOUBLE_HIGH (operands[1]) == -1
3550               && CONST_DOUBLE_LOW (operands[1]) < 0)))
3551     abort ();
3552
3553   /* Check if GCC is setting up a block move that will end up using FP
3554      registers as temporaries.  We must make sure this is acceptable.  */
3555   if (GET_CODE (operands[0]) == MEM
3556       && GET_CODE (operands[1]) == MEM
3557       && mode == DImode
3558       && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
3559           || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
3560       && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
3561                                             ? 32 : MEM_ALIGN (operands[0])))
3562             || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
3563                                                ? 32 
3564                                                : MEM_ALIGN (operands[1]))))
3565       && ! MEM_VOLATILE_P (operands [0])
3566       && ! MEM_VOLATILE_P (operands [1]))
3567     {
3568       emit_move_insn (adjust_address (operands[0], SImode, 0),
3569                       adjust_address (operands[1], SImode, 0));
3570       emit_move_insn (adjust_address (operands[0], SImode, 4),
3571                       adjust_address (operands[1], SImode, 4));
3572       return;
3573     }
3574
3575   if (!no_new_pseudos)
3576     {
3577       if (GET_CODE (operands[1]) == MEM && optimize > 0
3578           && (mode == QImode || mode == HImode || mode == SImode)
3579           && GET_MODE_SIZE (mode) < GET_MODE_SIZE (word_mode))
3580         {
3581           rtx reg = gen_reg_rtx (word_mode);
3582
3583           emit_insn (gen_rtx_SET (word_mode, reg,
3584                                   gen_rtx_ZERO_EXTEND (word_mode,
3585                                                        operands[1])));
3586           operands[1] = gen_lowpart (mode, reg);
3587         }
3588       if (GET_CODE (operands[0]) != REG)
3589         operands[1] = force_reg (mode, operands[1]);
3590     }
3591
3592   if (mode == SFmode && ! TARGET_POWERPC
3593       && TARGET_HARD_FLOAT && TARGET_FPRS
3594       && GET_CODE (operands[0]) == MEM)
3595     {
3596       int regnum;
3597
3598       if (reload_in_progress || reload_completed)
3599         regnum = true_regnum (operands[1]);
3600       else if (GET_CODE (operands[1]) == REG)
3601         regnum = REGNO (operands[1]);
3602       else
3603         regnum = -1;
3604       
3605       /* If operands[1] is a register, on POWER it may have
3606          double-precision data in it, so truncate it to single
3607          precision.  */
3608       if (FP_REGNO_P (regnum) || regnum >= FIRST_PSEUDO_REGISTER)
3609         {
3610           rtx newreg;
3611           newreg = (no_new_pseudos ? operands[1] : gen_reg_rtx (mode));
3612           emit_insn (gen_aux_truncdfsf2 (newreg, operands[1]));
3613           operands[1] = newreg;
3614         }
3615     }
3616
3617   /* Recognize the case where operand[1] is a reference to thread-local
3618      data and load its address to a register.  */
3619   if (GET_CODE (operands[1]) == SYMBOL_REF)
3620     {
3621       enum tls_model model = SYMBOL_REF_TLS_MODEL (operands[1]);
3622       if (model != 0)
3623         operands[1] = rs6000_legitimize_tls_address (operands[1], model);
3624     }
3625
3626   /* Handle the case where reload calls us with an invalid address.  */
3627   if (reload_in_progress && mode == Pmode
3628       && (! general_operand (operands[1], mode)
3629           || ! nonimmediate_operand (operands[0], mode)))
3630     goto emit_set;
3631
3632   /* Handle the case of CONSTANT_P_RTX.  */
3633   if (GET_CODE (operands[1]) == CONSTANT_P_RTX)
3634     goto emit_set;
3635
3636   /* 128-bit constant floating-point values on Darwin should really be
3637      loaded as two parts.  */
3638   if ((DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_DARWIN)
3639       && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128
3640       && mode == TFmode && GET_CODE (operands[1]) == CONST_DOUBLE)
3641     {
3642       /* DImode is used, not DFmode, because simplify_gen_subreg doesn't
3643          know how to get a DFmode SUBREG of a TFmode.  */
3644       rs6000_emit_move (simplify_gen_subreg (DImode, operands[0], mode, 0),
3645                         simplify_gen_subreg (DImode, operands[1], mode, 0),
3646                         DImode);
3647       rs6000_emit_move (simplify_gen_subreg (DImode, operands[0], mode,
3648                                              GET_MODE_SIZE (DImode)),
3649                         simplify_gen_subreg (DImode, operands[1], mode,
3650                                              GET_MODE_SIZE (DImode)),
3651                         DImode);
3652       return;
3653     }
3654
3655   /* FIXME:  In the long term, this switch statement should go away
3656      and be replaced by a sequence of tests based on things like
3657      mode == Pmode.  */
3658   switch (mode)
3659     {
3660     case HImode:
3661     case QImode:
3662       if (CONSTANT_P (operands[1])
3663           && GET_CODE (operands[1]) != CONST_INT)
3664         operands[1] = force_const_mem (mode, operands[1]);
3665       break;
3666
3667     case TFmode:
3668     case DFmode:
3669     case SFmode:
3670       if (CONSTANT_P (operands[1]) 
3671           && ! easy_fp_constant (operands[1], mode))
3672         operands[1] = force_const_mem (mode, operands[1]);
3673       break;
3674       
3675     case V16QImode:
3676     case V8HImode:
3677     case V4SFmode:
3678     case V4SImode:
3679     case V4HImode:
3680     case V2SFmode:
3681     case V2SImode:
3682     case V1DImode:
3683       if (CONSTANT_P (operands[1])
3684           && !easy_vector_constant (operands[1], mode))
3685         operands[1] = force_const_mem (mode, operands[1]);
3686       break;
3687       
3688     case SImode:
3689     case DImode:
3690       /* Use default pattern for address of ELF small data */
3691       if (TARGET_ELF
3692           && mode == Pmode
3693           && DEFAULT_ABI == ABI_V4
3694           && (GET_CODE (operands[1]) == SYMBOL_REF 
3695               || GET_CODE (operands[1]) == CONST)
3696           && small_data_operand (operands[1], mode))
3697         {
3698           emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
3699           return;
3700         }
3701
3702       if (DEFAULT_ABI == ABI_V4
3703           && mode == Pmode && mode == SImode
3704           && flag_pic == 1 && got_operand (operands[1], mode))
3705         {
3706           emit_insn (gen_movsi_got (operands[0], operands[1]));
3707           return;
3708         }
3709
3710       if ((TARGET_ELF || DEFAULT_ABI == ABI_DARWIN)
3711           && TARGET_NO_TOC
3712           && ! flag_pic
3713           && mode == Pmode
3714           && CONSTANT_P (operands[1])
3715           && GET_CODE (operands[1]) != HIGH
3716           && GET_CODE (operands[1]) != CONST_INT)
3717         {
3718           rtx target = (no_new_pseudos ? operands[0] : gen_reg_rtx (mode));
3719
3720           /* If this is a function address on -mcall-aixdesc,
3721              convert it to the address of the descriptor.  */
3722           if (DEFAULT_ABI == ABI_AIX
3723               && GET_CODE (operands[1]) == SYMBOL_REF
3724               && XSTR (operands[1], 0)[0] == '.')
3725             {
3726               const char *name = XSTR (operands[1], 0);
3727               rtx new_ref;
3728               while (*name == '.')
3729                 name++;
3730               new_ref = gen_rtx_SYMBOL_REF (Pmode, name);
3731               CONSTANT_POOL_ADDRESS_P (new_ref)
3732                 = CONSTANT_POOL_ADDRESS_P (operands[1]);
3733               SYMBOL_REF_FLAGS (new_ref) = SYMBOL_REF_FLAGS (operands[1]);
3734               SYMBOL_REF_USED (new_ref) = SYMBOL_REF_USED (operands[1]);
3735               SYMBOL_REF_DECL (new_ref) = SYMBOL_REF_DECL (operands[1]);
3736               operands[1] = new_ref;
3737             }
3738
3739           if (DEFAULT_ABI == ABI_DARWIN)
3740             {
3741 #if TARGET_MACHO
3742               if (MACHO_DYNAMIC_NO_PIC_P)
3743                 {
3744                   /* Take care of any required data indirection.  */
3745                   operands[1] = rs6000_machopic_legitimize_pic_address (
3746                                   operands[1], mode, operands[0]);
3747                   if (operands[0] != operands[1])
3748                     emit_insn (gen_rtx_SET (VOIDmode,
3749                                             operands[0], operands[1]));
3750                   return;
3751                 }
3752 #endif
3753               emit_insn (gen_macho_high (target, operands[1]));
3754               emit_insn (gen_macho_low (operands[0], target, operands[1]));
3755               return;
3756             }
3757
3758           emit_insn (gen_elf_high (target, operands[1]));
3759           emit_insn (gen_elf_low (operands[0], target, operands[1]));
3760           return;
3761         }
3762
3763       /* If this is a SYMBOL_REF that refers to a constant pool entry,
3764          and we have put it in the TOC, we just need to make a TOC-relative
3765          reference to it.  */
3766       if (TARGET_TOC
3767           && GET_CODE (operands[1]) == SYMBOL_REF
3768           && constant_pool_expr_p (operands[1])
3769           && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (operands[1]),
3770                                               get_pool_mode (operands[1])))
3771         {
3772           operands[1] = create_TOC_reference (operands[1]);
3773         }
3774       else if (mode == Pmode
3775                && CONSTANT_P (operands[1])
3776                && ((GET_CODE (operands[1]) != CONST_INT
3777                     && ! easy_fp_constant (operands[1], mode))
3778                    || (GET_CODE (operands[1]) == CONST_INT
3779                        && num_insns_constant (operands[1], mode) > 2)
3780                    || (GET_CODE (operands[0]) == REG
3781                        && FP_REGNO_P (REGNO (operands[0]))))
3782                && GET_CODE (operands[1]) != HIGH
3783                && ! legitimate_constant_pool_address_p (operands[1])
3784                && ! toc_relative_expr_p (operands[1]))
3785         {
3786           /* Emit a USE operation so that the constant isn't deleted if
3787              expensive optimizations are turned on because nobody
3788              references it.  This should only be done for operands that
3789              contain SYMBOL_REFs with CONSTANT_POOL_ADDRESS_P set.
3790              This should not be done for operands that contain LABEL_REFs.
3791              For now, we just handle the obvious case.  */
3792           if (GET_CODE (operands[1]) != LABEL_REF)
3793             emit_insn (gen_rtx_USE (VOIDmode, operands[1]));
3794
3795 #if TARGET_MACHO
3796           /* Darwin uses a special PIC legitimizer.  */
3797           if (DEFAULT_ABI == ABI_DARWIN && MACHOPIC_INDIRECT)
3798             {
3799               operands[1] =
3800                 rs6000_machopic_legitimize_pic_address (operands[1], mode,
3801                                                         operands[0]);
3802               if (operands[0] != operands[1])
3803                 emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
3804               return;
3805             }
3806 #endif
3807
3808           /* If we are to limit the number of things we put in the TOC and
3809              this is a symbol plus a constant we can add in one insn,
3810              just put the symbol in the TOC and add the constant.  Don't do
3811              this if reload is in progress.  */
3812           if (GET_CODE (operands[1]) == CONST
3813               && TARGET_NO_SUM_IN_TOC && ! reload_in_progress
3814               && GET_CODE (XEXP (operands[1], 0)) == PLUS
3815               && add_operand (XEXP (XEXP (operands[1], 0), 1), mode)
3816               && (GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == LABEL_REF
3817                   || GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
3818               && ! side_effects_p (operands[0]))
3819             {
3820               rtx sym =
3821                 force_const_mem (mode, XEXP (XEXP (operands[1], 0), 0));
3822               rtx other = XEXP (XEXP (operands[1], 0), 1);
3823
3824               sym = force_reg (mode, sym);
3825               if (mode == SImode)
3826                 emit_insn (gen_addsi3 (operands[0], sym, other));
3827               else
3828                 emit_insn (gen_adddi3 (operands[0], sym, other));
3829               return;
3830             }
3831
3832           operands[1] = force_const_mem (mode, operands[1]);
3833
3834           if (TARGET_TOC 
3835               && constant_pool_expr_p (XEXP (operands[1], 0))
3836               && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (
3837                         get_pool_constant (XEXP (operands[1], 0)),
3838                         get_pool_mode (XEXP (operands[1], 0))))
3839             {
3840               operands[1]
3841                 = gen_rtx_MEM (mode,
3842                                create_TOC_reference (XEXP (operands[1], 0)));
3843               set_mem_alias_set (operands[1], get_TOC_alias_set ());
3844               RTX_UNCHANGING_P (operands[1]) = 1;
3845             }
3846         }
3847       break;
3848
3849     case TImode:
3850       if (GET_CODE (operands[0]) == MEM
3851           && GET_CODE (XEXP (operands[0], 0)) != REG
3852           && ! reload_in_progress)
3853         operands[0]
3854           = replace_equiv_address (operands[0],
3855                                    copy_addr_to_reg (XEXP (operands[0], 0)));
3856
3857       if (GET_CODE (operands[1]) == MEM
3858           && GET_CODE (XEXP (operands[1], 0)) != REG
3859           && ! reload_in_progress)
3860         operands[1]
3861           = replace_equiv_address (operands[1],
3862                                    copy_addr_to_reg (XEXP (operands[1], 0)));
3863       if (TARGET_POWER)
3864         {
3865           emit_insn (gen_rtx_PARALLEL (VOIDmode,
3866                        gen_rtvec (2,
3867                                   gen_rtx_SET (VOIDmode,
3868                                                operands[0], operands[1]),
3869                                   gen_rtx_CLOBBER (VOIDmode,
3870                                                    gen_rtx_SCRATCH (SImode)))));
3871           return;
3872         }
3873       break;
3874
3875     default:
3876       abort ();
3877     }
3878
3879   /* Above, we may have called force_const_mem which may have returned
3880      an invalid address.  If we can, fix this up; otherwise, reload will
3881      have to deal with it.  */
3882   if (GET_CODE (operands[1]) == MEM && ! reload_in_progress)
3883     operands[1] = validize_mem (operands[1]);
3884
3885  emit_set:
3886   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
3887 }
3888 \f
3889 /* Nonzero if we can use a floating-point register to pass this arg.  */
3890 #define USE_FP_FOR_ARG_P(CUM,MODE,TYPE)         \
3891   (GET_MODE_CLASS (MODE) == MODE_FLOAT          \
3892    && (CUM)->fregno <= FP_ARG_MAX_REG           \
3893    && TARGET_HARD_FLOAT && TARGET_FPRS)
3894
3895 /* Nonzero if we can use an AltiVec register to pass this arg.  */
3896 #define USE_ALTIVEC_FOR_ARG_P(CUM,MODE,TYPE,NAMED)      \
3897   (ALTIVEC_VECTOR_MODE (MODE)                           \
3898    && (CUM)->vregno <= ALTIVEC_ARG_MAX_REG              \
3899    && TARGET_ALTIVEC_ABI                                \
3900    && (NAMED))
3901
3902 /* Return a nonzero value to say to return the function value in
3903    memory, just as large structures are always returned.  TYPE will be
3904    the data type of the value, and FNTYPE will be the type of the
3905    function doing the returning, or @code{NULL} for libcalls.
3906
3907    The AIX ABI for the RS/6000 specifies that all structures are
3908    returned in memory.  The Darwin ABI does the same.  The SVR4 ABI
3909    specifies that structures <= 8 bytes are returned in r3/r4, but a
3910    draft put them in memory, and GCC used to implement the draft
3911    instead of the final standard.  Therefore, TARGET_AIX_STRUCT_RET
3912    controls this instead of DEFAULT_ABI; V.4 targets needing backward
3913    compatibility can change DRAFT_V4_STRUCT_RET to override the
3914    default, and -m switches get the final word.  See
3915    rs6000_override_options for more details.
3916
3917    The PPC32 SVR4 ABI uses IEEE double extended for long double, if 128-bit
3918    long double support is enabled.  These values are returned in memory.
3919
3920    int_size_in_bytes returns -1 for variable size objects, which go in
3921    memory always.  The cast to unsigned makes -1 > 8.  */
3922
3923 static bool
3924 rs6000_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
3925 {
3926   if (AGGREGATE_TYPE_P (type)
3927       && (TARGET_AIX_STRUCT_RET
3928           || (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8))
3929     return true;
3930   if (DEFAULT_ABI == ABI_V4 && TYPE_MODE (type) == TFmode)
3931     return true;
3932   return false;
3933 }
3934
3935 /* Initialize a variable CUM of type CUMULATIVE_ARGS
3936    for a call to a function whose data type is FNTYPE.
3937    For a library call, FNTYPE is 0.
3938
3939    For incoming args we set the number of arguments in the prototype large
3940    so we never return a PARALLEL.  */
3941
3942 void
3943 init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype, 
3944                       rtx libname ATTRIBUTE_UNUSED, int incoming,
3945                       int libcall, int n_named_args)
3946 {
3947   static CUMULATIVE_ARGS zero_cumulative;
3948
3949   *cum = zero_cumulative;
3950   cum->words = 0;
3951   cum->fregno = FP_ARG_MIN_REG;
3952   cum->vregno = ALTIVEC_ARG_MIN_REG;
3953   cum->prototype = (fntype && TYPE_ARG_TYPES (fntype));
3954   cum->call_cookie = ((DEFAULT_ABI == ABI_V4 && libcall)
3955                       ? CALL_LIBCALL : CALL_NORMAL);
3956   cum->sysv_gregno = GP_ARG_MIN_REG;
3957   cum->stdarg = fntype
3958     && (TYPE_ARG_TYPES (fntype) != 0
3959         && (TREE_VALUE (tree_last  (TYPE_ARG_TYPES (fntype)))
3960             != void_type_node));
3961
3962   cum->nargs_prototype = 0;
3963   if (incoming || cum->prototype)
3964     cum->nargs_prototype = n_named_args;
3965
3966   /* Check for a longcall attribute.  */
3967   if (fntype
3968       && lookup_attribute ("longcall", TYPE_ATTRIBUTES (fntype))
3969       && !lookup_attribute ("shortcall", TYPE_ATTRIBUTES (fntype)))
3970     cum->call_cookie = CALL_LONG;
3971
3972   if (TARGET_DEBUG_ARG)
3973     {
3974       fprintf (stderr, "\ninit_cumulative_args:");
3975       if (fntype)
3976         {
3977           tree ret_type = TREE_TYPE (fntype);
3978           fprintf (stderr, " ret code = %s,",
3979                    tree_code_name[ (int)TREE_CODE (ret_type) ]);
3980         }
3981
3982       if (cum->call_cookie & CALL_LONG)
3983         fprintf (stderr, " longcall,");
3984
3985       fprintf (stderr, " proto = %d, nargs = %d\n",
3986                cum->prototype, cum->nargs_prototype);
3987     }
3988   
3989     if (fntype 
3990         && !TARGET_ALTIVEC 
3991         && TARGET_ALTIVEC_ABI
3992         && ALTIVEC_VECTOR_MODE (TYPE_MODE (TREE_TYPE (fntype))))
3993       {
3994         error ("Cannot return value in vector register because"
3995                " altivec instructions are disabled, use -maltivec"
3996                " to enable them.");
3997       }
3998 }
3999 \f
4000 /* If defined, a C expression which determines whether, and in which
4001    direction, to pad out an argument with extra space.  The value
4002    should be of type `enum direction': either `upward' to pad above
4003    the argument, `downward' to pad below, or `none' to inhibit
4004    padding.
4005
4006    For the AIX ABI structs are always stored left shifted in their
4007    argument slot.  */
4008
4009 enum direction
4010 function_arg_padding (enum machine_mode mode, tree type)
4011 {
4012 #ifndef AGGREGATE_PADDING_FIXED
4013 #define AGGREGATE_PADDING_FIXED 0
4014 #endif
4015 #ifndef AGGREGATES_PAD_UPWARD_ALWAYS
4016 #define AGGREGATES_PAD_UPWARD_ALWAYS 0
4017 #endif
4018
4019   if (!AGGREGATE_PADDING_FIXED)
4020     {
4021       /* GCC used to pass structures of the same size as integer types as
4022          if they were in fact integers, ignoring FUNCTION_ARG_PADDING.
4023          ie. Structures of size 1 or 2 (or 4 when TARGET_64BIT) were
4024          passed padded downward, except that -mstrict-align further
4025          muddied the water in that multi-component structures of 2 and 4
4026          bytes in size were passed padded upward.
4027
4028          The following arranges for best compatibility with previous
4029          versions of gcc, but removes the -mstrict-align dependency.  */
4030       if (BYTES_BIG_ENDIAN)
4031         {
4032           HOST_WIDE_INT size = 0;