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