?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* target.def (target_option.init_struct): New hook.
[official-gcc.git] / gcc / config / spu / spu.c
blob254bd652bb08aa33517550752b0609f4d80fdcd4
1 /* Copyright (C) 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
2
3 This file is free software; you can redistribute it and/or modify it under
4 the terms of the GNU General Public License as published by the Free
5 Software Foundation; either version 3 of the License, or (at your option)
6 any later version.
7
8 This file is distributed in the hope that it will be useful, but WITHOUT
9 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
11 for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with GCC; see the file COPYING3. If not see
15 <http://www.gnu.org/licenses/>. */
16
17 #include "config.h"
18 #include "system.h"
19 #include "coretypes.h"
20 #include "tm.h"
21 #include "rtl.h"
22 #include "regs.h"
23 #include "hard-reg-set.h"
24 #include "insn-config.h"
25 #include "conditions.h"
26 #include "insn-attr.h"
27 #include "flags.h"
28 #include "recog.h"
29 #include "obstack.h"
30 #include "tree.h"
31 #include "expr.h"
32 #include "optabs.h"
33 #include "except.h"
34 #include "function.h"
35 #include "output.h"
36 #include "basic-block.h"
37 #include "integrate.h"
38 #include "diagnostic-core.h"
39 #include "toplev.h"
40 #include "ggc.h"
41 #include "hashtab.h"
42 #include "tm_p.h"
43 #include "target.h"
44 #include "target-def.h"
45 #include "langhooks.h"
46 #include "reload.h"
47 #include "cfglayout.h"
48 #include "sched-int.h"
49 #include "params.h"
50 #include "assert.h"
51 #include "machmode.h"
52 #include "gimple.h"
53 #include "tm-constrs.h"
54 #include "ddg.h"
55 #include "sbitmap.h"
56 #include "timevar.h"
57 #include "df.h"
58
59 /* Builtin types, data and prototypes. */
60
61 enum spu_builtin_type_index
62 {
63 SPU_BTI_END_OF_PARAMS,
64
65 /* We create new type nodes for these. */
66 SPU_BTI_V16QI,
67 SPU_BTI_V8HI,
68 SPU_BTI_V4SI,
69 SPU_BTI_V2DI,
70 SPU_BTI_V4SF,
71 SPU_BTI_V2DF,
72 SPU_BTI_UV16QI,
73 SPU_BTI_UV8HI,
74 SPU_BTI_UV4SI,
75 SPU_BTI_UV2DI,
76
77 /* A 16-byte type. (Implemented with V16QI_type_node) */
78 SPU_BTI_QUADWORD,
79
80 /* These all correspond to intSI_type_node */
81 SPU_BTI_7,
82 SPU_BTI_S7,
83 SPU_BTI_U7,
84 SPU_BTI_S10,
85 SPU_BTI_S10_4,
86 SPU_BTI_U14,
87 SPU_BTI_16,
88 SPU_BTI_S16,
89 SPU_BTI_S16_2,
90 SPU_BTI_U16,
91 SPU_BTI_U16_2,
92 SPU_BTI_U18,
93
94 /* These correspond to the standard types */
95 SPU_BTI_INTQI,
96 SPU_BTI_INTHI,
97 SPU_BTI_INTSI,
98 SPU_BTI_INTDI,
99
100 SPU_BTI_UINTQI,
101 SPU_BTI_UINTHI,
102 SPU_BTI_UINTSI,
103 SPU_BTI_UINTDI,
104
105 SPU_BTI_FLOAT,
106 SPU_BTI_DOUBLE,
107
108 SPU_BTI_VOID,
109 SPU_BTI_PTR,
110
111 SPU_BTI_MAX
112 };
113
114 #define V16QI_type_node (spu_builtin_types[SPU_BTI_V16QI])
115 #define V8HI_type_node (spu_builtin_types[SPU_BTI_V8HI])
116 #define V4SI_type_node (spu_builtin_types[SPU_BTI_V4SI])
117 #define V2DI_type_node (spu_builtin_types[SPU_BTI_V2DI])
118 #define V4SF_type_node (spu_builtin_types[SPU_BTI_V4SF])
119 #define V2DF_type_node (spu_builtin_types[SPU_BTI_V2DF])
120 #define unsigned_V16QI_type_node (spu_builtin_types[SPU_BTI_UV16QI])
121 #define unsigned_V8HI_type_node (spu_builtin_types[SPU_BTI_UV8HI])
122 #define unsigned_V4SI_type_node (spu_builtin_types[SPU_BTI_UV4SI])
123 #define unsigned_V2DI_type_node (spu_builtin_types[SPU_BTI_UV2DI])
124
125 static GTY(()) tree spu_builtin_types[SPU_BTI_MAX];
126
127 struct spu_builtin_range
128 {
129 int low, high;
130 };
131
132 static struct spu_builtin_range spu_builtin_range[] = {
133 {-0x40ll, 0x7fll}, /* SPU_BTI_7 */
134 {-0x40ll, 0x3fll}, /* SPU_BTI_S7 */
135 {0ll, 0x7fll}, /* SPU_BTI_U7 */
136 {-0x200ll, 0x1ffll}, /* SPU_BTI_S10 */
137 {-0x2000ll, 0x1fffll}, /* SPU_BTI_S10_4 */
138 {0ll, 0x3fffll}, /* SPU_BTI_U14 */
139 {-0x8000ll, 0xffffll}, /* SPU_BTI_16 */
140 {-0x8000ll, 0x7fffll}, /* SPU_BTI_S16 */
141 {-0x20000ll, 0x1ffffll}, /* SPU_BTI_S16_2 */
142 {0ll, 0xffffll}, /* SPU_BTI_U16 */
143 {0ll, 0x3ffffll}, /* SPU_BTI_U16_2 */
144 {0ll, 0x3ffffll}, /* SPU_BTI_U18 */
145 };
146
147 \f
148 /* Target specific attribute specifications. */
149 char regs_ever_allocated[FIRST_PSEUDO_REGISTER];
150
151 /* Prototypes and external defs. */
152 static void spu_option_override (void);
153 static void spu_option_init_struct (struct gcc_options *opts);
154 static void spu_option_default_params (void);
155 static void spu_init_builtins (void);
156 static tree spu_builtin_decl (unsigned, bool);
157 static bool spu_scalar_mode_supported_p (enum machine_mode mode);
158 static bool spu_vector_mode_supported_p (enum machine_mode mode);
159 static bool spu_legitimate_address_p (enum machine_mode, rtx, bool);
160 static bool spu_addr_space_legitimate_address_p (enum machine_mode, rtx,
161 bool, addr_space_t);
162 static rtx adjust_operand (rtx op, HOST_WIDE_INT * start);
163 static rtx get_pic_reg (void);
164 static int need_to_save_reg (int regno, int saving);
165 static rtx frame_emit_store (int regno, rtx addr, HOST_WIDE_INT offset);
166 static rtx frame_emit_load (int regno, rtx addr, HOST_WIDE_INT offset);
167 static rtx frame_emit_add_imm (rtx dst, rtx src, HOST_WIDE_INT imm,
168 rtx scratch);
169 static void emit_nop_for_insn (rtx insn);
170 static bool insn_clobbers_hbr (rtx insn);
171 static void spu_emit_branch_hint (rtx before, rtx branch, rtx target,
172 int distance, sbitmap blocks);
173 static rtx spu_emit_vector_compare (enum rtx_code rcode, rtx op0, rtx op1,
174 enum machine_mode dmode);
175 static rtx get_branch_target (rtx branch);
176 static void spu_machine_dependent_reorg (void);
177 static int spu_sched_issue_rate (void);
178 static int spu_sched_variable_issue (FILE * dump, int verbose, rtx insn,
179 int can_issue_more);
180 static int get_pipe (rtx insn);
181 static int spu_sched_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost);
182 static void spu_sched_init_global (FILE *, int, int);
183 static void spu_sched_init (FILE *, int, int);
184 static int spu_sched_reorder (FILE *, int, rtx *, int *, int);
185 static tree spu_handle_fndecl_attribute (tree * node, tree name, tree args,
186 int flags,
187 bool *no_add_attrs);
188 static tree spu_handle_vector_attribute (tree * node, tree name, tree args,
189 int flags,
190 bool *no_add_attrs);
191 static int spu_naked_function_p (tree func);
192 static bool spu_pass_by_reference (CUMULATIVE_ARGS *cum, enum machine_mode mode,
193 const_tree type, bool named);
194 static rtx spu_function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode,
195 const_tree type, bool named);
196 static void spu_function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode,
197 const_tree type, bool named);
198 static tree spu_build_builtin_va_list (void);
199 static void spu_va_start (tree, rtx);
200 static tree spu_gimplify_va_arg_expr (tree valist, tree type,
201 gimple_seq * pre_p, gimple_seq * post_p);
202 static int store_with_one_insn_p (rtx mem);
203 static int mem_is_padded_component_ref (rtx x);
204 static int reg_aligned_for_addr (rtx x);
205 static bool spu_assemble_integer (rtx x, unsigned int size, int aligned_p);
206 static void spu_asm_globalize_label (FILE * file, const char *name);
207 static bool spu_rtx_costs (rtx x, int code, int outer_code,
208 int *total, bool speed);
209 static bool spu_function_ok_for_sibcall (tree decl, tree exp);
210 static void spu_init_libfuncs (void);
211 static bool spu_return_in_memory (const_tree type, const_tree fntype);
212 static void fix_range (const char *);
213 static void spu_encode_section_info (tree, rtx, int);
214 static rtx spu_legitimize_address (rtx, rtx, enum machine_mode);
215 static rtx spu_addr_space_legitimize_address (rtx, rtx, enum machine_mode,
216 addr_space_t);
217 static tree spu_builtin_mul_widen_even (tree);
218 static tree spu_builtin_mul_widen_odd (tree);
219 static tree spu_builtin_mask_for_load (void);
220 static int spu_builtin_vectorization_cost (enum vect_cost_for_stmt, tree, int);
221 static bool spu_vector_alignment_reachable (const_tree, bool);
222 static tree spu_builtin_vec_perm (tree, tree *);
223 static enum machine_mode spu_addr_space_pointer_mode (addr_space_t);
224 static enum machine_mode spu_addr_space_address_mode (addr_space_t);
225 static bool spu_addr_space_subset_p (addr_space_t, addr_space_t);
226 static rtx spu_addr_space_convert (rtx, tree, tree);
227 static int spu_sms_res_mii (struct ddg *g);
228 static void asm_file_start (void);
229 static unsigned int spu_section_type_flags (tree, const char *, int);
230 static section *spu_select_section (tree, int, unsigned HOST_WIDE_INT);
231 static void spu_unique_section (tree, int);
232 static rtx spu_expand_load (rtx, rtx, rtx, int);
233 static void spu_trampoline_init (rtx, tree, rtx);
234
235 /* Which instruction set architecture to use. */
236 int spu_arch;
237 /* Which cpu are we tuning for. */
238 int spu_tune;
239
240 /* The hardware requires 8 insns between a hint and the branch it
241 effects. This variable describes how many rtl instructions the
242 compiler needs to see before inserting a hint, and then the compiler
243 will insert enough nops to make it at least 8 insns. The default is
244 for the compiler to allow up to 2 nops be emitted. The nops are
245 inserted in pairs, so we round down. */
246 int spu_hint_dist = (8*4) - (2*4);
247
248 /* Determines whether we run variable tracking in machine dependent
249 reorganization. */
250 static int spu_flag_var_tracking;
251
252 enum spu_immediate {
253 SPU_NONE,
254 SPU_IL,
255 SPU_ILA,
256 SPU_ILH,
257 SPU_ILHU,
258 SPU_ORI,
259 SPU_ORHI,
260 SPU_ORBI,
261 SPU_IOHL
262 };
263 enum immediate_class
264 {
265 IC_POOL, /* constant pool */
266 IC_IL1, /* one il* instruction */
267 IC_IL2, /* both ilhu and iohl instructions */
268 IC_IL1s, /* one il* instruction */
269 IC_IL2s, /* both ilhu and iohl instructions */
270 IC_FSMBI, /* the fsmbi instruction */
271 IC_CPAT, /* one of the c*d instructions */
272 IC_FSMBI2 /* fsmbi plus 1 other instruction */
273 };
274
275 static enum spu_immediate which_immediate_load (HOST_WIDE_INT val);
276 static enum spu_immediate which_logical_immediate (HOST_WIDE_INT val);
277 static int cpat_info(unsigned char *arr, int size, int *prun, int *pstart);
278 static enum immediate_class classify_immediate (rtx op,
279 enum machine_mode mode);
280
281 static enum machine_mode spu_unwind_word_mode (void);
282
283 static enum machine_mode
284 spu_libgcc_cmp_return_mode (void);
285
286 static enum machine_mode
287 spu_libgcc_shift_count_mode (void);
288
289 /* Pointer mode for __ea references. */
290 #define EAmode (spu_ea_model != 32 ? DImode : SImode)
291
292 \f
293 /* Table of machine attributes. */
294 static const struct attribute_spec spu_attribute_table[] =
295 {
296 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
297 { "naked", 0, 0, true, false, false, spu_handle_fndecl_attribute },
298 { "spu_vector", 0, 0, false, true, false, spu_handle_vector_attribute },
299 { NULL, 0, 0, false, false, false, NULL }
300 };
301 \f
302 /* TARGET overrides. */
303
304 #undef TARGET_ADDR_SPACE_POINTER_MODE
305 #define TARGET_ADDR_SPACE_POINTER_MODE spu_addr_space_pointer_mode
306
307 #undef TARGET_ADDR_SPACE_ADDRESS_MODE
308 #define TARGET_ADDR_SPACE_ADDRESS_MODE spu_addr_space_address_mode
309
310 #undef TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
311 #define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P \
312 spu_addr_space_legitimate_address_p
313
314 #undef TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS
315 #define TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS spu_addr_space_legitimize_address
316
317 #undef TARGET_ADDR_SPACE_SUBSET_P
318 #define TARGET_ADDR_SPACE_SUBSET_P spu_addr_space_subset_p
319
320 #undef TARGET_ADDR_SPACE_CONVERT
321 #define TARGET_ADDR_SPACE_CONVERT spu_addr_space_convert
322
323 #undef TARGET_INIT_BUILTINS
324 #define TARGET_INIT_BUILTINS spu_init_builtins
325 #undef TARGET_BUILTIN_DECL
326 #define TARGET_BUILTIN_DECL spu_builtin_decl
327
328 #undef TARGET_EXPAND_BUILTIN
329 #define TARGET_EXPAND_BUILTIN spu_expand_builtin
330
331 #undef TARGET_UNWIND_WORD_MODE
332 #define TARGET_UNWIND_WORD_MODE spu_unwind_word_mode
333
334 #undef TARGET_LEGITIMIZE_ADDRESS
335 #define TARGET_LEGITIMIZE_ADDRESS spu_legitimize_address
336
337 /* The current assembler doesn't like .4byte foo@ppu, so use the normal .long
338 and .quad for the debugger. When it is known that the assembler is fixed,
339 these can be removed. */
340 #undef TARGET_ASM_UNALIGNED_SI_OP
341 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
342
343 #undef TARGET_ASM_ALIGNED_DI_OP
344 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
345
346 /* The .8byte directive doesn't seem to work well for a 32 bit
347 architecture. */
348 #undef TARGET_ASM_UNALIGNED_DI_OP
349 #define TARGET_ASM_UNALIGNED_DI_OP NULL
350
351 #undef TARGET_RTX_COSTS
352 #define TARGET_RTX_COSTS spu_rtx_costs
353
354 #undef TARGET_ADDRESS_COST
355 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
356
357 #undef TARGET_SCHED_ISSUE_RATE
358 #define TARGET_SCHED_ISSUE_RATE spu_sched_issue_rate
359
360 #undef TARGET_SCHED_INIT_GLOBAL
361 #define TARGET_SCHED_INIT_GLOBAL spu_sched_init_global
362
363 #undef TARGET_SCHED_INIT
364 #define TARGET_SCHED_INIT spu_sched_init
365
366 #undef TARGET_SCHED_VARIABLE_ISSUE
367 #define TARGET_SCHED_VARIABLE_ISSUE spu_sched_variable_issue
368
369 #undef TARGET_SCHED_REORDER
370 #define TARGET_SCHED_REORDER spu_sched_reorder
371
372 #undef TARGET_SCHED_REORDER2
373 #define TARGET_SCHED_REORDER2 spu_sched_reorder
374
375 #undef TARGET_SCHED_ADJUST_COST
376 #define TARGET_SCHED_ADJUST_COST spu_sched_adjust_cost
377
378 #undef TARGET_ATTRIBUTE_TABLE
379 #define TARGET_ATTRIBUTE_TABLE spu_attribute_table
380
381 #undef TARGET_ASM_INTEGER
382 #define TARGET_ASM_INTEGER spu_assemble_integer
383
384 #undef TARGET_SCALAR_MODE_SUPPORTED_P
385 #define TARGET_SCALAR_MODE_SUPPORTED_P spu_scalar_mode_supported_p
386
387 #undef TARGET_VECTOR_MODE_SUPPORTED_P
388 #define TARGET_VECTOR_MODE_SUPPORTED_P spu_vector_mode_supported_p
389
390 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
391 #define TARGET_FUNCTION_OK_FOR_SIBCALL spu_function_ok_for_sibcall
392
393 #undef TARGET_ASM_GLOBALIZE_LABEL
394 #define TARGET_ASM_GLOBALIZE_LABEL spu_asm_globalize_label
395
396 #undef TARGET_PASS_BY_REFERENCE
397 #define TARGET_PASS_BY_REFERENCE spu_pass_by_reference
398
399 #undef TARGET_FUNCTION_ARG
400 #define TARGET_FUNCTION_ARG spu_function_arg
401
402 #undef TARGET_FUNCTION_ARG_ADVANCE
403 #define TARGET_FUNCTION_ARG_ADVANCE spu_function_arg_advance
404
405 #undef TARGET_MUST_PASS_IN_STACK
406 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
407
408 #undef TARGET_BUILD_BUILTIN_VA_LIST
409 #define TARGET_BUILD_BUILTIN_VA_LIST spu_build_builtin_va_list
410
411 #undef TARGET_EXPAND_BUILTIN_VA_START
412 #define TARGET_EXPAND_BUILTIN_VA_START spu_va_start
413
414 #undef TARGET_SETUP_INCOMING_VARARGS
415 #define TARGET_SETUP_INCOMING_VARARGS spu_setup_incoming_varargs
416
417 #undef TARGET_MACHINE_DEPENDENT_REORG
418 #define TARGET_MACHINE_DEPENDENT_REORG spu_machine_dependent_reorg
419
420 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
421 #define TARGET_GIMPLIFY_VA_ARG_EXPR spu_gimplify_va_arg_expr
422
423 #undef TARGET_DEFAULT_TARGET_FLAGS
424 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT)
425
426 #undef TARGET_INIT_LIBFUNCS
427 #define TARGET_INIT_LIBFUNCS spu_init_libfuncs
428
429 #undef TARGET_RETURN_IN_MEMORY
430 #define TARGET_RETURN_IN_MEMORY spu_return_in_memory
431
432 #undef TARGET_ENCODE_SECTION_INFO
433 #define TARGET_ENCODE_SECTION_INFO spu_encode_section_info
434
435 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
436 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN spu_builtin_mul_widen_even
437
438 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
439 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD spu_builtin_mul_widen_odd
440
441 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
442 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD spu_builtin_mask_for_load
443
444 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
445 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST spu_builtin_vectorization_cost
446
447 #undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
448 #define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE spu_vector_alignment_reachable
449
450 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
451 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM spu_builtin_vec_perm
452
453 #undef TARGET_LIBGCC_CMP_RETURN_MODE
454 #define TARGET_LIBGCC_CMP_RETURN_MODE spu_libgcc_cmp_return_mode
455
456 #undef TARGET_LIBGCC_SHIFT_COUNT_MODE
457 #define TARGET_LIBGCC_SHIFT_COUNT_MODE spu_libgcc_shift_count_mode
458
459 #undef TARGET_SCHED_SMS_RES_MII
460 #define TARGET_SCHED_SMS_RES_MII spu_sms_res_mii
461
462 #undef TARGET_ASM_FILE_START
463 #define TARGET_ASM_FILE_START asm_file_start
464
465 #undef TARGET_SECTION_TYPE_FLAGS
466 #define TARGET_SECTION_TYPE_FLAGS spu_section_type_flags
467
468 #undef TARGET_ASM_SELECT_SECTION
469 #define TARGET_ASM_SELECT_SECTION spu_select_section
470
471 #undef TARGET_ASM_UNIQUE_SECTION
472 #define TARGET_ASM_UNIQUE_SECTION spu_unique_section
473
474 #undef TARGET_LEGITIMATE_ADDRESS_P
475 #define TARGET_LEGITIMATE_ADDRESS_P spu_legitimate_address_p
476
477 #undef TARGET_TRAMPOLINE_INIT
478 #define TARGET_TRAMPOLINE_INIT spu_trampoline_init
479
480 #undef TARGET_OPTION_OVERRIDE
481 #define TARGET_OPTION_OVERRIDE spu_option_override
482
483 #undef TARGET_OPTION_INIT_STRUCT
484 #define TARGET_OPTION_INIT_STRUCT spu_option_init_struct
485
486 #undef TARGET_OPTION_DEFAULT_PARAMS
487 #define TARGET_OPTION_DEFAULT_PARAMS spu_option_default_params
488
489 #undef TARGET_EXCEPT_UNWIND_INFO
490 #define TARGET_EXCEPT_UNWIND_INFO sjlj_except_unwind_info
491
492 struct gcc_target targetm = TARGET_INITIALIZER;
493
494 static void
495 spu_option_init_struct (struct gcc_options *opts)
496 {
497 /* With so many registers this is better on by default. */
498 opts->x_flag_rename_registers = 1;
499 }
500
501 /* Implement TARGET_OPTION_DEFAULT_PARAMS. */
502 static void
503 spu_option_default_params (void)
504 {
505 /* Override some of the default param values. With so many registers
506 larger values are better for these params. */
507 set_default_param_value (PARAM_MAX_PENDING_LIST_LENGTH, 128);
508 }
509
510 /* Implement TARGET_OPTION_OVERRIDE. */
511 static void
512 spu_option_override (void)
513 {
514 /* Small loops will be unpeeled at -O3. For SPU it is more important
515 to keep code small by default. */
516 if (!flag_unroll_loops && !flag_peel_loops)
517 maybe_set_param_value (PARAM_MAX_COMPLETELY_PEEL_TIMES, 1,
518 global_options.x_param_values,
519 global_options_set.x_param_values);
520
521 flag_omit_frame_pointer = 1;
522
523 /* Functions must be 8 byte aligned so we correctly handle dual issue */
524 if (align_functions < 8)
525 align_functions = 8;
526
527 spu_hint_dist = 8*4 - spu_max_nops*4;
528 if (spu_hint_dist < 0)
529 spu_hint_dist = 0;
530
531 if (spu_fixed_range_string)
532 fix_range (spu_fixed_range_string);
533
534 /* Determine processor architectural level. */
535 if (spu_arch_string)
536 {
537 if (strcmp (&spu_arch_string[0], "cell") == 0)
538 spu_arch = PROCESSOR_CELL;
539 else if (strcmp (&spu_arch_string[0], "celledp") == 0)
540 spu_arch = PROCESSOR_CELLEDP;
541 else
542 error ("Unknown architecture '%s'", &spu_arch_string[0]);
543 }
544
545 /* Determine processor to tune for. */
546 if (spu_tune_string)
547 {
548 if (strcmp (&spu_tune_string[0], "cell") == 0)
549 spu_tune = PROCESSOR_CELL;
550 else if (strcmp (&spu_tune_string[0], "celledp") == 0)
551 spu_tune = PROCESSOR_CELLEDP;
552 else
553 error ("Unknown architecture '%s'", &spu_tune_string[0]);
554 }
555
556 /* Change defaults according to the processor architecture. */
557 if (spu_arch == PROCESSOR_CELLEDP)
558 {
559 /* If no command line option has been otherwise specified, change
560 the default to -mno-safe-hints on celledp -- only the original
561 Cell/B.E. processors require this workaround. */
562 if (!(target_flags_explicit & MASK_SAFE_HINTS))
563 target_flags &= ~MASK_SAFE_HINTS;
564 }
565
566 REAL_MODE_FORMAT (SFmode) = &spu_single_format;
567 }
568 \f
569 /* Handle an attribute requiring a FUNCTION_DECL; arguments as in
570 struct attribute_spec.handler. */
571
572 /* True if MODE is valid for the target. By "valid", we mean able to
573 be manipulated in non-trivial ways. In particular, this means all
574 the arithmetic is supported. */
575 static bool
576 spu_scalar_mode_supported_p (enum machine_mode mode)
577 {
578 switch (mode)
579 {
580 case QImode:
581 case HImode:
582 case SImode:
583 case SFmode:
584 case DImode:
585 case TImode:
586 case DFmode:
587 return true;
588
589 default:
590 return false;
591 }
592 }
593
594 /* Similarly for vector modes. "Supported" here is less strict. At
595 least some operations are supported; need to check optabs or builtins
596 for further details. */
597 static bool
598 spu_vector_mode_supported_p (enum machine_mode mode)
599 {
600 switch (mode)
601 {
602 case V16QImode:
603 case V8HImode:
604 case V4SImode:
605 case V2DImode:
606 case V4SFmode:
607 case V2DFmode:
608 return true;
609
610 default:
611 return false;
612 }
613 }
614
615 /* GCC assumes that in a paradoxical SUBREG the inner mode occupies the
616 least significant bytes of the outer mode. This function returns
617 TRUE for the SUBREG's where this is correct. */
618 int
619 valid_subreg (rtx op)
620 {
621 enum machine_mode om = GET_MODE (op);
622 enum machine_mode im = GET_MODE (SUBREG_REG (op));
623 return om != VOIDmode && im != VOIDmode
624 && (GET_MODE_SIZE (im) == GET_MODE_SIZE (om)
625 || (GET_MODE_SIZE (im) <= 4 && GET_MODE_SIZE (om) <= 4)
626 || (GET_MODE_SIZE (im) >= 16 && GET_MODE_SIZE (om) >= 16));
627 }
628
629 /* When insv and ext[sz]v ar passed a TI SUBREG, we want to strip it off
630 and adjust the start offset. */
631 static rtx
632 adjust_operand (rtx op, HOST_WIDE_INT * start)
633 {
634 enum machine_mode mode;
635 int op_size;
636 /* Strip any paradoxical SUBREG. */
637 if (GET_CODE (op) == SUBREG
638 && (GET_MODE_BITSIZE (GET_MODE (op))
639 > GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op)))))
640 {
641 if (start)
642 *start -=
643 GET_MODE_BITSIZE (GET_MODE (op)) -
644 GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (op)));
645 op = SUBREG_REG (op);
646 }
647 /* If it is smaller than SI, assure a SUBREG */
648 op_size = GET_MODE_BITSIZE (GET_MODE (op));
649 if (op_size < 32)
650 {
651 if (start)
652 *start += 32 - op_size;
653 op_size = 32;
654 }
655 /* If it is not a MODE_INT (and/or it is smaller than SI) add a SUBREG. */
656 mode = mode_for_size (op_size, MODE_INT, 0);
657 if (mode != GET_MODE (op))
658 op = gen_rtx_SUBREG (mode, op, 0);
659 return op;
660 }
661
662 void
663 spu_expand_extv (rtx ops[], int unsignedp)
664 {
665 rtx dst = ops[0], src = ops[1];
666 HOST_WIDE_INT width = INTVAL (ops[2]);
667 HOST_WIDE_INT start = INTVAL (ops[3]);
668 HOST_WIDE_INT align_mask;
669 rtx s0, s1, mask, r0;
670
671 gcc_assert (REG_P (dst) && GET_MODE (dst) == TImode);
672
673 if (MEM_P (src))
674 {
675 /* First, determine if we need 1 TImode load or 2. We need only 1
676 if the bits being extracted do not cross the alignment boundary
677 as determined by the MEM and its address. */
678
679 align_mask = -MEM_ALIGN (src);
680 if ((start & align_mask) == ((start + width - 1) & align_mask))
681 {
682 /* Alignment is sufficient for 1 load. */
683 s0 = gen_reg_rtx (TImode);
684 r0 = spu_expand_load (s0, 0, src, start / 8);
685 start &= 7;
686 if (r0)
687 emit_insn (gen_rotqby_ti (s0, s0, r0));
688 }
689 else
690 {
691 /* Need 2 loads. */
692 s0 = gen_reg_rtx (TImode);
693 s1 = gen_reg_rtx (TImode);
694 r0 = spu_expand_load (s0, s1, src, start / 8);
695 start &= 7;
696
697 gcc_assert (start + width <= 128);
698 if (r0)
699 {
700 rtx r1 = gen_reg_rtx (SImode);
701 mask = gen_reg_rtx (TImode);
702 emit_move_insn (mask, GEN_INT (-1));
703 emit_insn (gen_rotqby_ti (s0, s0, r0));
704 emit_insn (gen_rotqby_ti (s1, s1, r0));
705 if (GET_CODE (r0) == CONST_INT)
706 r1 = GEN_INT (INTVAL (r0) & 15);
707 else
708 emit_insn (gen_andsi3 (r1, r0, GEN_INT (15)));
709 emit_insn (gen_shlqby_ti (mask, mask, r1));
710 emit_insn (gen_selb (s0, s1, s0, mask));
711 }
712 }
713
714 }
715 else if (GET_CODE (src) == SUBREG)
716 {
717 rtx r = SUBREG_REG (src);
718 gcc_assert (REG_P (r) && SCALAR_INT_MODE_P (GET_MODE (r)));
719 s0 = gen_reg_rtx (TImode);
720 if (GET_MODE_SIZE (GET_MODE (r)) < GET_MODE_SIZE (TImode))
721 emit_insn (gen_rtx_SET (VOIDmode, s0, gen_rtx_ZERO_EXTEND (TImode, r)));
722 else
723 emit_move_insn (s0, src);
724 }
725 else
726 {
727 gcc_assert (REG_P (src) && GET_MODE (src) == TImode);
728 s0 = gen_reg_rtx (TImode);
729 emit_move_insn (s0, src);
730 }
731
732 /* Now s0 is TImode and contains the bits to extract at start. */
733
734 if (start)
735 emit_insn (gen_rotlti3 (s0, s0, GEN_INT (start)));
736
737 if (128 - width)
738 {
739 tree c = build_int_cst (NULL_TREE, 128 - width);
740 s0 = expand_shift (RSHIFT_EXPR, TImode, s0, c, s0, unsignedp);
741 }
742
743 emit_move_insn (dst, s0);
744 }
745
746 void
747 spu_expand_insv (rtx ops[])
748 {
749 HOST_WIDE_INT width = INTVAL (ops[1]);
750 HOST_WIDE_INT start = INTVAL (ops[2]);
751 HOST_WIDE_INT maskbits;
752 enum machine_mode dst_mode, src_mode;
753 rtx dst = ops[0], src = ops[3];
754 int dst_size, src_size;
755 rtx mask;
756 rtx shift_reg;
757 int shift;
758
759
760 if (GET_CODE (ops[0]) == MEM)
761 dst = gen_reg_rtx (TImode);
762 else
763 dst = adjust_operand (dst, &start);
764 dst_mode = GET_MODE (dst);
765 dst_size = GET_MODE_BITSIZE (GET_MODE (dst));
766
767 if (CONSTANT_P (src))
768 {
769 enum machine_mode m =
770 (width <= 32 ? SImode : width <= 64 ? DImode : TImode);
771 src = force_reg (m, convert_to_mode (m, src, 0));
772 }
773 src = adjust_operand (src, 0);
774 src_mode = GET_MODE (src);
775 src_size = GET_MODE_BITSIZE (GET_MODE (src));
776
777 mask = gen_reg_rtx (dst_mode);
778 shift_reg = gen_reg_rtx (dst_mode);
779 shift = dst_size - start - width;
780
781 /* It's not safe to use subreg here because the compiler assumes
782 that the SUBREG_REG is right justified in the SUBREG. */
783 convert_move (shift_reg, src, 1);
784
785 if (shift > 0)
786 {
787 switch (dst_mode)
788 {
789 case SImode:
790 emit_insn (gen_ashlsi3 (shift_reg, shift_reg, GEN_INT (shift)));
791 break;
792 case DImode:
793 emit_insn (gen_ashldi3 (shift_reg, shift_reg, GEN_INT (shift)));
794 break;
795 case TImode:
796 emit_insn (gen_ashlti3 (shift_reg, shift_reg, GEN_INT (shift)));
797 break;
798 default:
799 abort ();
800 }
801 }
802 else if (shift < 0)
803 abort ();
804
805 switch (dst_size)
806 {
807 case 32:
808 maskbits = (-1ll << (32 - width - start));
809 if (start)
810 maskbits += (1ll << (32 - start));
811 emit_move_insn (mask, GEN_INT (maskbits));
812 break;
813 case 64:
814 maskbits = (-1ll << (64 - width - start));
815 if (start)
816 maskbits += (1ll << (64 - start));
817 emit_move_insn (mask, GEN_INT (maskbits));
818 break;
819 case 128:
820 {
821 unsigned char arr[16];
822 int i = start / 8;
823 memset (arr, 0, sizeof (arr));
824 arr[i] = 0xff >> (start & 7);
825 for (i++; i <= (start + width - 1) / 8; i++)
826 arr[i] = 0xff;
827 arr[i - 1] &= 0xff << (7 - ((start + width - 1) & 7));
828 emit_move_insn (mask, array_to_constant (TImode, arr));
829 }
830 break;
831 default:
832 abort ();
833 }
834 if (GET_CODE (ops[0]) == MEM)
835 {
836 rtx low = gen_reg_rtx (SImode);
837 rtx rotl = gen_reg_rtx (SImode);
838 rtx mask0 = gen_reg_rtx (TImode);
839 rtx addr;
840 rtx addr0;
841 rtx addr1;
842 rtx mem;
843
844 addr = force_reg (Pmode, XEXP (ops[0], 0));
845 addr0 = gen_rtx_AND (Pmode, addr, GEN_INT (-16));
846 emit_insn (gen_andsi3 (low, addr, GEN_INT (15)));
847 emit_insn (gen_negsi2 (rotl, low));
848 emit_insn (gen_rotqby_ti (shift_reg, shift_reg, rotl));
849 emit_insn (gen_rotqmby_ti (mask0, mask, rotl));
850 mem = change_address (ops[0], TImode, addr0);
851 set_mem_alias_set (mem, 0);
852 emit_move_insn (dst, mem);
853 emit_insn (gen_selb (dst, dst, shift_reg, mask0));
854 if (start + width > MEM_ALIGN (ops[0]))
855 {
856 rtx shl = gen_reg_rtx (SImode);
857 rtx mask1 = gen_reg_rtx (TImode);
858 rtx dst1 = gen_reg_rtx (TImode);
859 rtx mem1;
860 addr1 = plus_constant (addr, 16);
861 addr1 = gen_rtx_AND (Pmode, addr1, GEN_INT (-16));
862 emit_insn (gen_subsi3 (shl, GEN_INT (16), low));
863 emit_insn (gen_shlqby_ti (mask1, mask, shl));
864 mem1 = change_address (ops[0], TImode, addr1);
865 set_mem_alias_set (mem1, 0);
866 emit_move_insn (dst1, mem1);
867 emit_insn (gen_selb (dst1, dst1, shift_reg, mask1));
868 emit_move_insn (mem1, dst1);
869 }
870 emit_move_insn (mem, dst);
871 }
872 else
873 emit_insn (gen_selb (dst, copy_rtx (dst), shift_reg, mask));
874 }
875
876
877 int
878 spu_expand_block_move (rtx ops[])
879 {
880 HOST_WIDE_INT bytes, align, offset;
881 rtx src, dst, sreg, dreg, target;
882 int i;
883 if (GET_CODE (ops[2]) != CONST_INT
884 || GET_CODE (ops[3]) != CONST_INT
885 || INTVAL (ops[2]) > (HOST_WIDE_INT) (MOVE_RATIO (optimize_insn_for_speed_p ()) * 8))
886 return 0;
887
888 bytes = INTVAL (ops[2]);
889 align = INTVAL (ops[3]);
890
891 if (bytes <= 0)
892 return 1;
893
894 dst = ops[0];
895 src = ops[1];
896
897 if (align == 16)
898 {
899 for (offset = 0; offset + 16 <= bytes; offset += 16)
900 {
901 dst = adjust_address (ops[0], V16QImode, offset);
902 src = adjust_address (ops[1], V16QImode, offset);
903 emit_move_insn (dst, src);
904 }
905 if (offset < bytes)
906 {
907 rtx mask;
908 unsigned char arr[16] = { 0 };
909 for (i = 0; i < bytes - offset; i++)
910 arr[i] = 0xff;
911 dst = adjust_address (ops[0], V16QImode, offset);
912 src = adjust_address (ops[1], V16QImode, offset);
913 mask = gen_reg_rtx (V16QImode);
914 sreg = gen_reg_rtx (V16QImode);
915 dreg = gen_reg_rtx (V16QImode);
916 target = gen_reg_rtx (V16QImode);
917 emit_move_insn (mask, array_to_constant (V16QImode, arr));
918 emit_move_insn (dreg, dst);
919 emit_move_insn (sreg, src);
920 emit_insn (gen_selb (target, dreg, sreg, mask));
921 emit_move_insn (dst, target);
922 }
923 return 1;
924 }
925 return 0;
926 }
927
928 enum spu_comp_code
929 { SPU_EQ, SPU_GT, SPU_GTU };
930
931 int spu_comp_icode[12][3] = {
932 {CODE_FOR_ceq_qi, CODE_FOR_cgt_qi, CODE_FOR_clgt_qi},
933 {CODE_FOR_ceq_hi, CODE_FOR_cgt_hi, CODE_FOR_clgt_hi},
934 {CODE_FOR_ceq_si, CODE_FOR_cgt_si, CODE_FOR_clgt_si},
935 {CODE_FOR_ceq_di, CODE_FOR_cgt_di, CODE_FOR_clgt_di},
936 {CODE_FOR_ceq_ti, CODE_FOR_cgt_ti, CODE_FOR_clgt_ti},
937 {CODE_FOR_ceq_sf, CODE_FOR_cgt_sf, 0},
938 {CODE_FOR_ceq_df, CODE_FOR_cgt_df, 0},
939 {CODE_FOR_ceq_v16qi, CODE_FOR_cgt_v16qi, CODE_FOR_clgt_v16qi},
940 {CODE_FOR_ceq_v8hi, CODE_FOR_cgt_v8hi, CODE_FOR_clgt_v8hi},
941 {CODE_FOR_ceq_v4si, CODE_FOR_cgt_v4si, CODE_FOR_clgt_v4si},
942 {CODE_FOR_ceq_v4sf, CODE_FOR_cgt_v4sf, 0},
943 {CODE_FOR_ceq_v2df, CODE_FOR_cgt_v2df, 0},
944 };
945
946 /* Generate a compare for CODE. Return a brand-new rtx that represents
947 the result of the compare. GCC can figure this out too if we don't
948 provide all variations of compares, but GCC always wants to use
949 WORD_MODE, we can generate better code in most cases if we do it
950 ourselves. */
951 void
952 spu_emit_branch_or_set (int is_set, rtx cmp, rtx operands[])
953 {
954 int reverse_compare = 0;
955 int reverse_test = 0;
956 rtx compare_result, eq_result;
957 rtx comp_rtx, eq_rtx;
958 enum machine_mode comp_mode;
959 enum machine_mode op_mode;
960 enum spu_comp_code scode, eq_code;
961 enum insn_code ior_code;
962 enum rtx_code code = GET_CODE (cmp);
963 rtx op0 = XEXP (cmp, 0);
964 rtx op1 = XEXP (cmp, 1);
965 int index;
966 int eq_test = 0;
967
968 /* When op1 is a CONST_INT change (X >= C) to (X > C-1),
969 and so on, to keep the constant in operand 1. */
970 if (GET_CODE (op1) == CONST_INT)
971 {
972 HOST_WIDE_INT val = INTVAL (op1) - 1;
973 if (trunc_int_for_mode (val, GET_MODE (op0)) == val)
974 switch (code)
975 {
976 case GE:
977 op1 = GEN_INT (val);
978 code = GT;
979 break;
980 case LT:
981 op1 = GEN_INT (val);
982 code = LE;
983 break;
984 case GEU:
985 op1 = GEN_INT (val);
986 code = GTU;
987 break;
988 case LTU:
989 op1 = GEN_INT (val);
990 code = LEU;
991 break;
992 default:
993 break;
994 }
995 }
996
997 comp_mode = SImode;
998 op_mode = GET_MODE (op0);
999
1000 switch (code)
1001 {
1002 case GE:
1003 scode = SPU_GT;
1004 if (HONOR_NANS (op_mode))
1005 {
1006 reverse_compare = 0;
1007 reverse_test = 0;
1008 eq_test = 1;
1009 eq_code = SPU_EQ;
1010 }
1011 else
1012 {
1013 reverse_compare = 1;
1014 reverse_test = 1;
1015 }
1016 break;
1017 case LE:
1018 scode = SPU_GT;
1019 if (HONOR_NANS (op_mode))
1020 {
1021 reverse_compare = 1;
1022 reverse_test = 0;
1023 eq_test = 1;
1024 eq_code = SPU_EQ;
1025 }
1026 else
1027 {
1028 reverse_compare = 0;
1029 reverse_test = 1;
1030 }
1031 break;
1032 case LT:
1033 reverse_compare = 1;
1034 reverse_test = 0;
1035 scode = SPU_GT;
1036 break;
1037 case GEU:
1038 reverse_compare = 1;
1039 reverse_test = 1;
1040 scode = SPU_GTU;
1041 break;
1042 case LEU:
1043 reverse_compare = 0;
1044 reverse_test = 1;
1045 scode = SPU_GTU;
1046 break;
1047 case LTU:
1048 reverse_compare = 1;
1049 reverse_test = 0;
1050 scode = SPU_GTU;
1051 break;
1052 case NE:
1053 reverse_compare = 0;
1054 reverse_test = 1;
1055 scode = SPU_EQ;
1056 break;
1057
1058 case EQ:
1059 scode = SPU_EQ;
1060 break;
1061 case GT:
1062 scode = SPU_GT;
1063 break;
1064 case GTU:
1065 scode = SPU_GTU;
1066 break;
1067 default:
1068 scode = SPU_EQ;
1069 break;
1070 }
1071
1072 switch (op_mode)
1073 {
1074 case QImode:
1075 index = 0;
1076 comp_mode = QImode;
1077 break;
1078 case HImode:
1079 index = 1;
1080 comp_mode = HImode;
1081 break;
1082 case SImode:
1083 index = 2;
1084 break;
1085 case DImode:
1086 index = 3;
1087 break;
1088 case TImode:
1089 index = 4;
1090 break;
1091 case SFmode:
1092 index = 5;
1093 break;
1094 case DFmode:
1095 index = 6;
1096 break;
1097 case V16QImode:
1098 index = 7;
1099 comp_mode = op_mode;
1100 break;
1101 case V8HImode:
1102 index = 8;
1103 comp_mode = op_mode;
1104 break;
1105 case V4SImode:
1106 index = 9;
1107 comp_mode = op_mode;
1108 break;
1109 case V4SFmode:
1110 index = 10;
1111 comp_mode = V4SImode;
1112 break;
1113 case V2DFmode:
1114 index = 11;
1115 comp_mode = V2DImode;
1116 break;
1117 case V2DImode:
1118 default:
1119 abort ();
1120 }
1121
1122 if (GET_MODE (op1) == DFmode
1123 && (scode != SPU_GT && scode != SPU_EQ))
1124 abort ();
1125
1126 if (is_set == 0 && op1 == const0_rtx
1127 && (GET_MODE (op0) == SImode
1128 || GET_MODE (op0) == HImode) && scode == SPU_EQ)
1129 {
1130 /* Don't need to set a register with the result when we are
1131 comparing against zero and branching. */
1132 reverse_test = !reverse_test;
1133 compare_result = op0;
1134 }
1135 else
1136 {
1137 compare_result = gen_reg_rtx (comp_mode);
1138
1139 if (reverse_compare)
1140 {
1141 rtx t = op1;
1142 op1 = op0;
1143 op0 = t;
1144 }
1145
1146 if (spu_comp_icode[index][scode] == 0)
1147 abort ();
1148
1149 if (!(*insn_data[spu_comp_icode[index][scode]].operand[1].predicate)
1150 (op0, op_mode))
1151 op0 = force_reg (op_mode, op0);
1152 if (!(*insn_data[spu_comp_icode[index][scode]].operand[2].predicate)
1153 (op1, op_mode))
1154 op1 = force_reg (op_mode, op1);
1155 comp_rtx = GEN_FCN (spu_comp_icode[index][scode]) (compare_result,
1156 op0, op1);
1157 if (comp_rtx == 0)
1158 abort ();
1159 emit_insn (comp_rtx);
1160
1161 if (eq_test)
1162 {
1163 eq_result = gen_reg_rtx (comp_mode);
1164 eq_rtx = GEN_FCN (spu_comp_icode[index][eq_code]) (eq_result,
1165 op0, op1);
1166 if (eq_rtx == 0)
1167 abort ();
1168 emit_insn (eq_rtx);
1169 ior_code = optab_handler (ior_optab, comp_mode);
1170 gcc_assert (ior_code != CODE_FOR_nothing);
1171 emit_insn (GEN_FCN (ior_code)
1172 (compare_result, compare_result, eq_result));
1173 }
1174 }
1175
1176 if (is_set == 0)
1177 {
1178 rtx bcomp;
1179 rtx loc_ref;
1180
1181 /* We don't have branch on QI compare insns, so we convert the
1182 QI compare result to a HI result. */
1183 if (comp_mode == QImode)
1184 {
1185 rtx old_res = compare_result;
1186 compare_result = gen_reg_rtx (HImode);
1187 comp_mode = HImode;
1188 emit_insn (gen_extendqihi2 (compare_result, old_res));
1189 }
1190
1191 if (reverse_test)
1192 bcomp = gen_rtx_EQ (comp_mode, compare_result, const0_rtx);
1193 else
1194 bcomp = gen_rtx_NE (comp_mode, compare_result, const0_rtx);
1195
1196 loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
1197 emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
1198 gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
1199 loc_ref, pc_rtx)));
1200 }
1201 else if (is_set == 2)
1202 {
1203 rtx target = operands[0];
1204 int compare_size = GET_MODE_BITSIZE (comp_mode);
1205 int target_size = GET_MODE_BITSIZE (GET_MODE (target));
1206 enum machine_mode mode = mode_for_size (target_size, MODE_INT, 0);
1207 rtx select_mask;
1208 rtx op_t = operands[2];
1209 rtx op_f = operands[3];
1210
1211 /* The result of the comparison can be SI, HI or QI mode. Create a
1212 mask based on that result. */
1213 if (target_size > compare_size)
1214 {
1215 select_mask = gen_reg_rtx (mode);
1216 emit_insn (gen_extend_compare (select_mask, compare_result));
1217 }
1218 else if (target_size < compare_size)
1219 select_mask =
1220 gen_rtx_SUBREG (mode, compare_result,
1221 (compare_size - target_size) / BITS_PER_UNIT);
1222 else if (comp_mode != mode)
1223 select_mask = gen_rtx_SUBREG (mode, compare_result, 0);
1224 else
1225 select_mask = compare_result;
1226
1227 if (GET_MODE (target) != GET_MODE (op_t)
1228 || GET_MODE (target) != GET_MODE (op_f))
1229 abort ();
1230
1231 if (reverse_test)
1232 emit_insn (gen_selb (target, op_t, op_f, select_mask));
1233 else
1234 emit_insn (gen_selb (target, op_f, op_t, select_mask));
1235 }
1236 else
1237 {
1238 rtx target = operands[0];
1239 if (reverse_test)
1240 emit_insn (gen_rtx_SET (VOIDmode, compare_result,
1241 gen_rtx_NOT (comp_mode, compare_result)));
1242 if (GET_MODE (target) == SImode && GET_MODE (compare_result) == HImode)
1243 emit_insn (gen_extendhisi2 (target, compare_result));
1244 else if (GET_MODE (target) == SImode
1245 && GET_MODE (compare_result) == QImode)
1246 emit_insn (gen_extend_compare (target, compare_result));
1247 else
1248 emit_move_insn (target, compare_result);
1249 }
1250 }
1251
1252 HOST_WIDE_INT
1253 const_double_to_hwint (rtx x)
1254 {
1255 HOST_WIDE_INT val;
1256 REAL_VALUE_TYPE rv;
1257 if (GET_MODE (x) == SFmode)
1258 {
1259 REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
1260 REAL_VALUE_TO_TARGET_SINGLE (rv, val);
1261 }
1262 else if (GET_MODE (x) == DFmode)
1263 {
1264 long l[2];
1265 REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
1266 REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
1267 val = l[0];
1268 val = (val << 32) | (l[1] & 0xffffffff);
1269 }
1270 else
1271 abort ();
1272 return val;
1273 }
1274
1275 rtx
1276 hwint_to_const_double (enum machine_mode mode, HOST_WIDE_INT v)
1277 {
1278 long tv[2];
1279 REAL_VALUE_TYPE rv;
1280 gcc_assert (mode == SFmode || mode == DFmode);
1281
1282 if (mode == SFmode)
1283 tv[0] = (v << 32) >> 32;
1284 else if (mode == DFmode)
1285 {
1286 tv[1] = (v << 32) >> 32;
1287 tv[0] = v >> 32;
1288 }
1289 real_from_target (&rv, tv, mode);
1290 return CONST_DOUBLE_FROM_REAL_VALUE (rv, mode);
1291 }
1292
1293 void
1294 print_operand_address (FILE * file, register rtx addr)
1295 {
1296 rtx reg;
1297 rtx offset;
1298
1299 if (GET_CODE (addr) == AND
1300 && GET_CODE (XEXP (addr, 1)) == CONST_INT
1301 && INTVAL (XEXP (addr, 1)) == -16)
1302 addr = XEXP (addr, 0);
1303
1304 switch (GET_CODE (addr))
1305 {
1306 case REG:
1307 fprintf (file, "0(%s)", reg_names[REGNO (addr)]);
1308 break;
1309
1310 case PLUS:
1311 reg = XEXP (addr, 0);
1312 offset = XEXP (addr, 1);
1313 if (GET_CODE (offset) == REG)
1314 {
1315 fprintf (file, "%s,%s", reg_names[REGNO (reg)],
1316 reg_names[REGNO (offset)]);
1317 }
1318 else if (GET_CODE (offset) == CONST_INT)
1319 {
1320 fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%s)",
1321 INTVAL (offset), reg_names[REGNO (reg)]);
1322 }
1323 else
1324 abort ();
1325 break;
1326
1327 case CONST:
1328 case LABEL_REF:
1329 case SYMBOL_REF:
1330 case CONST_INT:
1331 output_addr_const (file, addr);
1332 break;
1333
1334 default:
1335 debug_rtx (addr);
1336 abort ();
1337 }
1338 }
1339
1340 void
1341 print_operand (FILE * file, rtx x, int code)
1342 {
1343 enum machine_mode mode = GET_MODE (x);
1344 HOST_WIDE_INT val;
1345 unsigned char arr[16];
1346 int xcode = GET_CODE (x);
1347 int i, info;
1348 if (GET_MODE (x) == VOIDmode)
1349 switch (code)
1350 {
1351 case 'L': /* 128 bits, signed */
1352 case 'm': /* 128 bits, signed */
1353 case 'T': /* 128 bits, signed */
1354 case 't': /* 128 bits, signed */
1355 mode = TImode;
1356 break;
1357 case 'K': /* 64 bits, signed */
1358 case 'k': /* 64 bits, signed */
1359 case 'D': /* 64 bits, signed */
1360 case 'd': /* 64 bits, signed */
1361 mode = DImode;
1362 break;
1363 case 'J': /* 32 bits, signed */
1364 case 'j': /* 32 bits, signed */
1365 case 's': /* 32 bits, signed */
1366 case 'S': /* 32 bits, signed */
1367 mode = SImode;
1368 break;
1369 }
1370 switch (code)
1371 {
1372
1373 case 'j': /* 32 bits, signed */
1374 case 'k': /* 64 bits, signed */
1375 case 'm': /* 128 bits, signed */
1376 if (xcode == CONST_INT
1377 || xcode == CONST_DOUBLE || xcode == CONST_VECTOR)
1378 {
1379 gcc_assert (logical_immediate_p (x, mode));
1380 constant_to_array (mode, x, arr);
1381 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
1382 val = trunc_int_for_mode (val, SImode);
1383 switch (which_logical_immediate (val))
1384 {
1385 case SPU_ORI:
1386 break;
1387 case SPU_ORHI:
1388 fprintf (file, "h");
1389 break;
1390 case SPU_ORBI:
1391 fprintf (file, "b");
1392 break;
1393 default:
1394 gcc_unreachable();
1395 }
1396 }
1397 else
1398 gcc_unreachable();
1399 return;
1400
1401 case 'J': /* 32 bits, signed */
1402 case 'K': /* 64 bits, signed */
1403 case 'L': /* 128 bits, signed */
1404 if (xcode == CONST_INT
1405 || xcode == CONST_DOUBLE || xcode == CONST_VECTOR)
1406 {
1407 gcc_assert (logical_immediate_p (x, mode)
1408 || iohl_immediate_p (x, mode));
1409 constant_to_array (mode, x, arr);
1410 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
1411 val = trunc_int_for_mode (val, SImode);
1412 switch (which_logical_immediate (val))
1413 {
1414 case SPU_ORI:
1415 case SPU_IOHL:
1416 break;
1417 case SPU_ORHI:
1418 val = trunc_int_for_mode (val, HImode);
1419 break;
1420 case SPU_ORBI:
1421 val = trunc_int_for_mode (val, QImode);
1422 break;
1423 default:
1424 gcc_unreachable();
1425 }
1426 fprintf (file, HOST_WIDE_INT_PRINT_DEC, val);
1427 }
1428 else
1429 gcc_unreachable();
1430 return;
1431
1432 case 't': /* 128 bits, signed */
1433 case 'd': /* 64 bits, signed */
1434 case 's': /* 32 bits, signed */
1435 if (CONSTANT_P (x))
1436 {
1437 enum immediate_class c = classify_immediate (x, mode);
1438 switch (c)
1439 {
1440 case IC_IL1:
1441 constant_to_array (mode, x, arr);
1442 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
1443 val = trunc_int_for_mode (val, SImode);
1444 switch (which_immediate_load (val))
1445 {
1446 case SPU_IL:
1447 break;
1448 case SPU_ILA:
1449 fprintf (file, "a");
1450 break;
1451 case SPU_ILH:
1452 fprintf (file, "h");
1453 break;
1454 case SPU_ILHU:
1455 fprintf (file, "hu");
1456 break;
1457 default:
1458 gcc_unreachable ();
1459 }
1460 break;
1461 case IC_CPAT:
1462 constant_to_array (mode, x, arr);
1463 cpat_info (arr, GET_MODE_SIZE (mode), &info, 0);
1464 if (info == 1)
1465 fprintf (file, "b");
1466 else if (info == 2)
1467 fprintf (file, "h");
1468 else if (info == 4)
1469 fprintf (file, "w");
1470 else if (info == 8)
1471 fprintf (file, "d");
1472 break;
1473 case IC_IL1s:
1474 if (xcode == CONST_VECTOR)
1475 {
1476 x = CONST_VECTOR_ELT (x, 0);
1477 xcode = GET_CODE (x);
1478 }
1479 if (xcode == SYMBOL_REF || xcode == LABEL_REF || xcode == CONST)
1480 fprintf (file, "a");
1481 else if (xcode == HIGH)
1482 fprintf (file, "hu");
1483 break;
1484 case IC_FSMBI:
1485 case IC_FSMBI2:
1486 case IC_IL2:
1487 case IC_IL2s:
1488 case IC_POOL:
1489 abort ();
1490 }
1491 }
1492 else
1493 gcc_unreachable ();
1494 return;
1495
1496 case 'T': /* 128 bits, signed */
1497 case 'D': /* 64 bits, signed */
1498 case 'S': /* 32 bits, signed */
1499 if (CONSTANT_P (x))
1500 {
1501 enum immediate_class c = classify_immediate (x, mode);
1502 switch (c)
1503 {
1504 case IC_IL1:
1505 constant_to_array (mode, x, arr);
1506 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
1507 val = trunc_int_for_mode (val, SImode);
1508 switch (which_immediate_load (val))
1509 {
1510 case SPU_IL:
1511 case SPU_ILA:
1512 break;
1513 case SPU_ILH:
1514 case SPU_ILHU:
1515 val = trunc_int_for_mode (((arr[0] << 8) | arr[1]), HImode);
1516 break;
1517 default:
1518 gcc_unreachable ();
1519 }
1520 fprintf (file, HOST_WIDE_INT_PRINT_DEC, val);
1521 break;
1522 case IC_FSMBI:
1523 constant_to_array (mode, x, arr);
1524 val = 0;
1525 for (i = 0; i < 16; i++)
1526 {
1527 val <<= 1;
1528 val |= arr[i] & 1;
1529 }
1530 print_operand (file, GEN_INT (val), 0);
1531 break;
1532 case IC_CPAT:
1533 constant_to_array (mode, x, arr);
1534 cpat_info (arr, GET_MODE_SIZE (mode), 0, &info);
1535 fprintf (file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)info);
1536 break;
1537 case IC_IL1s:
1538 if (xcode == HIGH)
1539 x = XEXP (x, 0);
1540 if (GET_CODE (x) == CONST_VECTOR)
1541 x = CONST_VECTOR_ELT (x, 0);
1542 output_addr_const (file, x);
1543 if (xcode == HIGH)
1544 fprintf (file, "@h");
1545 break;
1546 case IC_IL2:
1547 case IC_IL2s:
1548 case IC_FSMBI2:
1549 case IC_POOL:
1550 abort ();
1551 }
1552 }
1553 else
1554 gcc_unreachable ();
1555 return;
1556
1557 case 'C':
1558 if (xcode == CONST_INT)
1559 {
1560 /* Only 4 least significant bits are relevant for generate
1561 control word instructions. */
1562 fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) & 15);
1563 return;
1564 }
1565 break;
1566
1567 case 'M': /* print code for c*d */
1568 if (GET_CODE (x) == CONST_INT)
1569 switch (INTVAL (x))
1570 {
1571 case 1:
1572 fprintf (file, "b");
1573 break;
1574 case 2:
1575 fprintf (file, "h");
1576 break;
1577 case 4:
1578 fprintf (file, "w");
1579 break;
1580 case 8:
1581 fprintf (file, "d");
1582 break;
1583 default:
1584 gcc_unreachable();
1585 }
1586 else
1587 gcc_unreachable();
1588 return;
1589
1590 case 'N': /* Negate the operand */
1591 if (xcode == CONST_INT)
1592 fprintf (file, HOST_WIDE_INT_PRINT_DEC, -INTVAL (x));
1593 else if (xcode == CONST_VECTOR)
1594 fprintf (file, HOST_WIDE_INT_PRINT_DEC,
1595 -INTVAL (CONST_VECTOR_ELT (x, 0)));
1596 return;
1597
1598 case 'I': /* enable/disable interrupts */
1599 if (xcode == CONST_INT)
1600 fprintf (file, "%s", INTVAL (x) == 0 ? "d" : "e");
1601 return;
1602
1603 case 'b': /* branch modifiers */
1604 if (xcode == REG)
1605 fprintf (file, "%s", GET_MODE (x) == HImode ? "h" : "");
1606 else if (COMPARISON_P (x))
1607 fprintf (file, "%s", xcode == NE ? "n" : "");
1608 return;
1609
1610 case 'i': /* indirect call */
1611 if (xcode == MEM)
1612 {
1613 if (GET_CODE (XEXP (x, 0)) == REG)
1614 /* Used in indirect function calls. */
1615 fprintf (file, "%s", reg_names[REGNO (XEXP (x, 0))]);
1616 else
1617 output_address (XEXP (x, 0));
1618 }
1619 return;
1620
1621 case 'p': /* load/store */
1622 if (xcode == MEM)
1623 {
1624 x = XEXP (x, 0);
1625 xcode = GET_CODE (x);
1626 }
1627 if (xcode == AND)
1628 {
1629 x = XEXP (x, 0);
1630 xcode = GET_CODE (x);
1631 }
1632 if (xcode == REG)
1633 fprintf (file, "d");
1634 else if (xcode == CONST_INT)
1635 fprintf (file, "a");
1636 else if (xcode == CONST || xcode == SYMBOL_REF || xcode == LABEL_REF)
1637 fprintf (file, "r");
1638 else if (xcode == PLUS || xcode == LO_SUM)
1639 {
1640 if (GET_CODE (XEXP (x, 1)) == REG)
1641 fprintf (file, "x");
1642 else
1643 fprintf (file, "d");
1644 }
1645 return;
1646
1647 case 'e':
1648 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1649 val &= 0x7;
1650 output_addr_const (file, GEN_INT (val));
1651 return;
1652
1653 case 'f':
1654 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1655 val &= 0x1f;
1656 output_addr_const (file, GEN_INT (val));
1657 return;
1658
1659 case 'g':
1660 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1661 val &= 0x3f;
1662 output_addr_const (file, GEN_INT (val));
1663 return;
1664
1665 case 'h':
1666 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1667 val = (val >> 3) & 0x1f;
1668 output_addr_const (file, GEN_INT (val));
1669 return;
1670
1671 case 'E':
1672 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1673 val = -val;
1674 val &= 0x7;
1675 output_addr_const (file, GEN_INT (val));
1676 return;
1677
1678 case 'F':
1679 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1680 val = -val;
1681 val &= 0x1f;
1682 output_addr_const (file, GEN_INT (val));
1683 return;
1684
1685 case 'G':
1686 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1687 val = -val;
1688 val &= 0x3f;
1689 output_addr_const (file, GEN_INT (val));
1690 return;
1691
1692 case 'H':
1693 val = xcode == CONST_INT ? INTVAL (x) : INTVAL (CONST_VECTOR_ELT (x, 0));
1694 val = -(val & -8ll);
1695 val = (val >> 3) & 0x1f;
1696 output_addr_const (file, GEN_INT (val));
1697 return;
1698
1699 case 'v':
1700 case 'w':
1701 constant_to_array (mode, x, arr);
1702 val = (((arr[0] << 1) + (arr[1] >> 7)) & 0xff) - 127;
1703 output_addr_const (file, GEN_INT (code == 'w' ? -val : val));
1704 return;
1705
1706 case 0:
1707 if (xcode == REG)
1708 fprintf (file, "%s", reg_names[REGNO (x)]);
1709 else if (xcode == MEM)
1710 output_address (XEXP (x, 0));
1711 else if (xcode == CONST_VECTOR)
1712 print_operand (file, CONST_VECTOR_ELT (x, 0), 0);
1713 else
1714 output_addr_const (file, x);
1715 return;
1716
1717 /* unused letters
1718 o qr u yz
1719 AB OPQR UVWXYZ */
1720 default:
1721 output_operand_lossage ("invalid %%xn code");
1722 }
1723 gcc_unreachable ();
1724 }
1725
1726 /* For PIC mode we've reserved PIC_OFFSET_TABLE_REGNUM, which is a
1727 caller saved register. For leaf functions it is more efficient to
1728 use a volatile register because we won't need to save and restore the
1729 pic register. This routine is only valid after register allocation
1730 is completed, so we can pick an unused register. */
1731 static rtx
1732 get_pic_reg (void)
1733 {
1734 rtx pic_reg = pic_offset_table_rtx;
1735 if (!reload_completed && !reload_in_progress)
1736 abort ();
1737 if (current_function_is_leaf && !df_regs_ever_live_p (LAST_ARG_REGNUM))
1738 pic_reg = gen_rtx_REG (SImode, LAST_ARG_REGNUM);
1739 return pic_reg;
1740 }
1741
1742 /* Split constant addresses to handle cases that are too large.
1743 Add in the pic register when in PIC mode.
1744 Split immediates that require more than 1 instruction. */
1745 int
1746 spu_split_immediate (rtx * ops)
1747 {
1748 enum machine_mode mode = GET_MODE (ops[0]);
1749 enum immediate_class c = classify_immediate (ops[1], mode);
1750
1751 switch (c)
1752 {
1753 case IC_IL2:
1754 {
1755 unsigned char arrhi[16];
1756 unsigned char arrlo[16];
1757 rtx to, temp, hi, lo;
1758 int i;
1759 enum machine_mode imode = mode;
1760 /* We need to do reals as ints because the constant used in the
1761 IOR might not be a legitimate real constant. */
1762 imode = int_mode_for_mode (mode);
1763 constant_to_array (mode, ops[1], arrhi);
1764 if (imode != mode)
1765 to = simplify_gen_subreg (imode, ops[0], mode, 0);
1766 else
1767 to = ops[0];
1768 temp = !can_create_pseudo_p () ? to : gen_reg_rtx (imode);
1769 for (i = 0; i < 16; i += 4)
1770 {
1771 arrlo[i + 2] = arrhi[i + 2];
1772 arrlo[i + 3] = arrhi[i + 3];
1773 arrlo[i + 0] = arrlo[i + 1] = 0;
1774 arrhi[i + 2] = arrhi[i + 3] = 0;
1775 }
1776 hi = array_to_constant (imode, arrhi);
1777 lo = array_to_constant (imode, arrlo);
1778 emit_move_insn (temp, hi);
1779 emit_insn (gen_rtx_SET
1780 (VOIDmode, to, gen_rtx_IOR (imode, temp, lo)));
1781 return 1;
1782 }
1783 case IC_FSMBI2:
1784 {
1785 unsigned char arr_fsmbi[16];
1786 unsigned char arr_andbi[16];
1787 rtx to, reg_fsmbi, reg_and;
1788 int i;
1789 enum machine_mode imode = mode;
1790 /* We need to do reals as ints because the constant used in the
1791 * AND might not be a legitimate real constant. */
1792 imode = int_mode_for_mode (mode);
1793 constant_to_array (mode, ops[1], arr_fsmbi);
1794 if (imode != mode)
1795 to = simplify_gen_subreg(imode, ops[0], GET_MODE (ops[0]), 0);
1796 else
1797 to = ops[0];
1798 for (i = 0; i < 16; i++)
1799 if (arr_fsmbi[i] != 0)
1800 {
1801 arr_andbi[0] = arr_fsmbi[i];
1802 arr_fsmbi[i] = 0xff;
1803 }
1804 for (i = 1; i < 16; i++)
1805 arr_andbi[i] = arr_andbi[0];
1806 reg_fsmbi = array_to_constant (imode, arr_fsmbi);
1807 reg_and = array_to_constant (imode, arr_andbi);
1808 emit_move_insn (to, reg_fsmbi);
1809 emit_insn (gen_rtx_SET
1810 (VOIDmode, to, gen_rtx_AND (imode, to, reg_and)));
1811 return 1;
1812 }
1813 case IC_POOL:
1814 if (reload_in_progress || reload_completed)
1815 {
1816 rtx mem = force_const_mem (mode, ops[1]);
1817 if (TARGET_LARGE_MEM)
1818 {
1819 rtx addr = gen_rtx_REG (Pmode, REGNO (ops[0]));
1820 emit_move_insn (addr, XEXP (mem, 0));
1821 mem = replace_equiv_address (mem, addr);
1822 }
1823 emit_move_insn (ops[0], mem);
1824 return 1;
1825 }
1826 break;
1827 case IC_IL1s:
1828 case IC_IL2s:
1829 if (reload_completed && GET_CODE (ops[1]) != HIGH)
1830 {
1831 if (c == IC_IL2s)
1832 {
1833 emit_move_insn (ops[0], gen_rtx_HIGH (mode, ops[1]));
1834 emit_move_insn (ops[0], gen_rtx_LO_SUM (mode, ops[0], ops[1]));
1835 }
1836 else if (flag_pic)
1837 emit_insn (gen_pic (ops[0], ops[1]));
1838 if (flag_pic)
1839 {
1840 rtx pic_reg = get_pic_reg ();
1841 emit_insn (gen_addsi3 (ops[0], ops[0], pic_reg));
1842 crtl->uses_pic_offset_table = 1;
1843 }
1844 return flag_pic || c == IC_IL2s;
1845 }
1846 break;
1847 case IC_IL1:
1848 case IC_FSMBI:
1849 case IC_CPAT:
1850 break;
1851 }
1852 return 0;
1853 }
1854
1855 /* SAVING is TRUE when we are generating the actual load and store
1856 instructions for REGNO. When determining the size of the stack
1857 needed for saving register we must allocate enough space for the
1858 worst case, because we don't always have the information early enough
1859 to not allocate it. But we can at least eliminate the actual loads
1860 and stores during the prologue/epilogue. */
1861 static int
1862 need_to_save_reg (int regno, int saving)
1863 {
1864 if (df_regs_ever_live_p (regno) && !call_used_regs[regno])
1865 return 1;
1866 if (flag_pic
1867 && regno == PIC_OFFSET_TABLE_REGNUM
1868 && (!saving || crtl->uses_pic_offset_table)
1869 && (!saving
1870 || !current_function_is_leaf || df_regs_ever_live_p (LAST_ARG_REGNUM)))
1871 return 1;
1872 return 0;
1873 }
1874
1875 /* This function is only correct starting with local register
1876 allocation */
1877 int
1878 spu_saved_regs_size (void)
1879 {
1880 int reg_save_size = 0;
1881 int regno;
1882
1883 for (regno = FIRST_PSEUDO_REGISTER - 1; regno >= 0; --regno)
1884 if (need_to_save_reg (regno, 0))
1885 reg_save_size += 0x10;
1886 return reg_save_size;
1887 }
1888
1889 static rtx
1890 frame_emit_store (int regno, rtx addr, HOST_WIDE_INT offset)
1891 {
1892 rtx reg = gen_rtx_REG (V4SImode, regno);
1893 rtx mem =
1894 gen_frame_mem (V4SImode, gen_rtx_PLUS (Pmode, addr, GEN_INT (offset)));
1895 return emit_insn (gen_movv4si (mem, reg));
1896 }
1897
1898 static rtx
1899 frame_emit_load (int regno, rtx addr, HOST_WIDE_INT offset)
1900 {
1901 rtx reg = gen_rtx_REG (V4SImode, regno);
1902 rtx mem =
1903 gen_frame_mem (V4SImode, gen_rtx_PLUS (Pmode, addr, GEN_INT (offset)));
1904 return emit_insn (gen_movv4si (reg, mem));
1905 }
1906
1907 /* This happens after reload, so we need to expand it. */
1908 static rtx
1909 frame_emit_add_imm (rtx dst, rtx src, HOST_WIDE_INT imm, rtx scratch)
1910 {
1911 rtx insn;
1912 if (satisfies_constraint_K (GEN_INT (imm)))
1913 {
1914 insn = emit_insn (gen_addsi3 (dst, src, GEN_INT (imm)));
1915 }
1916 else
1917 {
1918 emit_insn (gen_movsi (scratch, gen_int_mode (imm, SImode)));
1919 insn = emit_insn (gen_addsi3 (dst, src, scratch));
1920 if (REGNO (src) == REGNO (scratch))
1921 abort ();
1922 }
1923 return insn;
1924 }
1925
1926 /* Return nonzero if this function is known to have a null epilogue. */
1927
1928 int
1929 direct_return (void)
1930 {
1931 if (reload_completed)
1932 {
1933 if (cfun->static_chain_decl == 0
1934 && (spu_saved_regs_size ()
1935 + get_frame_size ()
1936 + crtl->outgoing_args_size
1937 + crtl->args.pretend_args_size == 0)
1938 && current_function_is_leaf)
1939 return 1;
1940 }
1941 return 0;
1942 }
1943
1944 /*
1945 The stack frame looks like this:
1946 +-------------+
1947 | incoming |
1948 | args |
1949 AP -> +-------------+
1950 | $lr save |
1951 +-------------+
1952 prev SP | back chain |
1953 +-------------+
1954 | var args |
1955 | reg save | crtl->args.pretend_args_size bytes
1956 +-------------+
1957 | ... |
1958 | saved regs | spu_saved_regs_size() bytes
1959 FP -> +-------------+
1960 | ... |
1961 | vars | get_frame_size() bytes
1962 HFP -> +-------------+
1963 | ... |
1964 | outgoing |
1965 | args | crtl->outgoing_args_size bytes
1966 +-------------+
1967 | $lr of next |
1968 | frame |
1969 +-------------+
1970 | back chain |
1971 SP -> +-------------+
1972
1973 */
1974 void
1975 spu_expand_prologue (void)
1976 {
1977 HOST_WIDE_INT size = get_frame_size (), offset, regno;
1978 HOST_WIDE_INT total_size;
1979 HOST_WIDE_INT saved_regs_size;
1980 rtx sp_reg = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
1981 rtx scratch_reg_0, scratch_reg_1;
1982 rtx insn, real;
1983
1984 if (flag_pic && optimize == 0)
1985 crtl->uses_pic_offset_table = 1;
1986
1987 if (spu_naked_function_p (current_function_decl))
1988 return;
1989
1990 scratch_reg_0 = gen_rtx_REG (SImode, LAST_ARG_REGNUM + 1);
1991 scratch_reg_1 = gen_rtx_REG (SImode, LAST_ARG_REGNUM + 2);
1992
1993 saved_regs_size = spu_saved_regs_size ();
1994 total_size = size + saved_regs_size
1995 + crtl->outgoing_args_size
1996 + crtl->args.pretend_args_size;
1997
1998 if (!current_function_is_leaf
1999 || cfun->calls_alloca || total_size > 0)
2000 total_size += STACK_POINTER_OFFSET;
2001
2002 /* Save this first because code after this might use the link
2003 register as a scratch register. */
2004 if (!current_function_is_leaf)
2005 {
2006 insn = frame_emit_store (LINK_REGISTER_REGNUM, sp_reg, 16);
2007 RTX_FRAME_RELATED_P (insn) = 1;
2008 }
2009
2010 if (total_size > 0)
2011 {
2012 offset = -crtl->args.pretend_args_size;
2013 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
2014 if (need_to_save_reg (regno, 1))
2015 {
2016 offset -= 16;
2017 insn = frame_emit_store (regno, sp_reg, offset);
2018 RTX_FRAME_RELATED_P (insn) = 1;
2019 }
2020 }
2021
2022 if (flag_pic && crtl->uses_pic_offset_table)
2023 {
2024 rtx pic_reg = get_pic_reg ();
2025 insn = emit_insn (gen_load_pic_offset (pic_reg, scratch_reg_0));
2026 insn = emit_insn (gen_subsi3 (pic_reg, pic_reg, scratch_reg_0));
2027 }
2028
2029 if (total_size > 0)
2030 {
2031 if (flag_stack_check)
2032 {
2033 /* We compare against total_size-1 because
2034 ($sp >= total_size) <=> ($sp > total_size-1) */
2035 rtx scratch_v4si = gen_rtx_REG (V4SImode, REGNO (scratch_reg_0));
2036 rtx sp_v4si = gen_rtx_REG (V4SImode, STACK_POINTER_REGNUM);
2037 rtx size_v4si = spu_const (V4SImode, total_size - 1);
2038 if (!satisfies_constraint_K (GEN_INT (total_size - 1)))
2039 {
2040 emit_move_insn (scratch_v4si, size_v4si);
2041 size_v4si = scratch_v4si;
2042 }
2043 emit_insn (gen_cgt_v4si (scratch_v4si, sp_v4si, size_v4si));
2044 emit_insn (gen_vec_extractv4si
2045 (scratch_reg_0, scratch_v4si, GEN_INT (1)));
2046 emit_insn (gen_spu_heq (scratch_reg_0, GEN_INT (0)));
2047 }
2048
2049 /* Adjust the stack pointer, and make sure scratch_reg_0 contains
2050 the value of the previous $sp because we save it as the back
2051 chain. */
2052 if (total_size <= 2000)
2053 {
2054 /* In this case we save the back chain first. */
2055 insn = frame_emit_store (STACK_POINTER_REGNUM, sp_reg, -total_size);
2056 insn =
2057 frame_emit_add_imm (sp_reg, sp_reg, -total_size, scratch_reg_0);
2058 }
2059 else
2060 {
2061 insn = emit_move_insn (scratch_reg_0, sp_reg);
2062 insn =
2063 frame_emit_add_imm (sp_reg, sp_reg, -total_size, scratch_reg_1);
2064 }
2065 RTX_FRAME_RELATED_P (insn) = 1;
2066 real = gen_addsi3 (sp_reg, sp_reg, GEN_INT (-total_size));
2067 add_reg_note (insn, REG_FRAME_RELATED_EXPR, real);
2068
2069 if (total_size > 2000)
2070 {
2071 /* Save the back chain ptr */
2072 insn = frame_emit_store (REGNO (scratch_reg_0), sp_reg, 0);
2073 }
2074
2075 if (frame_pointer_needed)
2076 {
2077 rtx fp_reg = gen_rtx_REG (Pmode, HARD_FRAME_POINTER_REGNUM);
2078 HOST_WIDE_INT fp_offset = STACK_POINTER_OFFSET
2079 + crtl->outgoing_args_size;
2080 /* Set the new frame_pointer */
2081 insn = frame_emit_add_imm (fp_reg, sp_reg, fp_offset, scratch_reg_0);
2082 RTX_FRAME_RELATED_P (insn) = 1;
2083 real = gen_addsi3 (fp_reg, sp_reg, GEN_INT (fp_offset));
2084 add_reg_note (insn, REG_FRAME_RELATED_EXPR, real);
2085 REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = STACK_BOUNDARY;
2086 }
2087 }
2088
2089 }
2090
2091 void
2092 spu_expand_epilogue (bool sibcall_p)
2093 {
2094 int size = get_frame_size (), offset, regno;
2095 HOST_WIDE_INT saved_regs_size, total_size;
2096 rtx sp_reg = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
2097 rtx jump, scratch_reg_0;
2098
2099 if (spu_naked_function_p (current_function_decl))
2100 return;
2101
2102 scratch_reg_0 = gen_rtx_REG (SImode, LAST_ARG_REGNUM + 1);
2103
2104 saved_regs_size = spu_saved_regs_size ();
2105 total_size = size + saved_regs_size
2106 + crtl->outgoing_args_size
2107 + crtl->args.pretend_args_size;
2108
2109 if (!current_function_is_leaf
2110 || cfun->calls_alloca || total_size > 0)
2111 total_size += STACK_POINTER_OFFSET;
2112
2113 if (total_size > 0)
2114 {
2115 if (cfun->calls_alloca)
2116 frame_emit_load (STACK_POINTER_REGNUM, sp_reg, 0);
2117 else
2118 frame_emit_add_imm (sp_reg, sp_reg, total_size, scratch_reg_0);
2119
2120
2121 if (saved_regs_size > 0)
2122 {
2123 offset = -crtl->args.pretend_args_size;
2124 for (regno = 0; regno < FIRST_PSEUDO_REGISTER; ++regno)
2125 if (need_to_save_reg (regno, 1))
2126 {
2127 offset -= 0x10;
2128 frame_emit_load (regno, sp_reg, offset);
2129 }
2130 }
2131 }
2132
2133 if (!current_function_is_leaf)
2134 frame_emit_load (LINK_REGISTER_REGNUM, sp_reg, 16);
2135
2136 if (!sibcall_p)
2137 {
2138 emit_use (gen_rtx_REG (SImode, LINK_REGISTER_REGNUM));
2139 jump = emit_jump_insn (gen__return ());
2140 emit_barrier_after (jump);
2141 }
2142
2143 }
2144
2145 rtx
2146 spu_return_addr (int count, rtx frame ATTRIBUTE_UNUSED)
2147 {
2148 if (count != 0)
2149 return 0;
2150 /* This is inefficient because it ends up copying to a save-register
2151 which then gets saved even though $lr has already been saved. But
2152 it does generate better code for leaf functions and we don't need
2153 to use RETURN_ADDRESS_POINTER_REGNUM to get it working. It's only
2154 used for __builtin_return_address anyway, so maybe we don't care if
2155 it's inefficient. */
2156 return get_hard_reg_initial_val (Pmode, LINK_REGISTER_REGNUM);
2157 }
2158 \f
2159
2160 /* Given VAL, generate a constant appropriate for MODE.
2161 If MODE is a vector mode, every element will be VAL.
2162 For TImode, VAL will be zero extended to 128 bits. */
2163 rtx
2164 spu_const (enum machine_mode mode, HOST_WIDE_INT val)
2165 {
2166 rtx inner;
2167 rtvec v;
2168 int units, i;
2169
2170 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
2171 || GET_MODE_CLASS (mode) == MODE_FLOAT
2172 || GET_MODE_CLASS (mode) == MODE_VECTOR_INT
2173 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT);
2174
2175 if (GET_MODE_CLASS (mode) == MODE_INT)
2176 return immed_double_const (val, 0, mode);
2177
2178 /* val is the bit representation of the float */
2179 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
2180 return hwint_to_const_double (mode, val);
2181
2182 if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
2183 inner = immed_double_const (val, 0, GET_MODE_INNER (mode));
2184 else
2185 inner = hwint_to_const_double (GET_MODE_INNER (mode), val);
2186
2187 units = GET_MODE_NUNITS (mode);
2188
2189 v = rtvec_alloc (units);
2190
2191 for (i = 0; i < units; ++i)
2192 RTVEC_ELT (v, i) = inner;
2193
2194 return gen_rtx_CONST_VECTOR (mode, v);
2195 }
2196
2197 /* Create a MODE vector constant from 4 ints. */
2198 rtx
2199 spu_const_from_ints(enum machine_mode mode, int a, int b, int c, int d)
2200 {
2201 unsigned char arr[16];
2202 arr[0] = (a >> 24) & 0xff;
2203 arr[1] = (a >> 16) & 0xff;
2204 arr[2] = (a >> 8) & 0xff;
2205 arr[3] = (a >> 0) & 0xff;
2206 arr[4] = (b >> 24) & 0xff;
2207 arr[5] = (b >> 16) & 0xff;
2208 arr[6] = (b >> 8) & 0xff;
2209 arr[7] = (b >> 0) & 0xff;
2210 arr[8] = (c >> 24) & 0xff;
2211 arr[9] = (c >> 16) & 0xff;
2212 arr[10] = (c >> 8) & 0xff;
2213 arr[11] = (c >> 0) & 0xff;
2214 arr[12] = (d >> 24) & 0xff;
2215 arr[13] = (d >> 16) & 0xff;
2216 arr[14] = (d >> 8) & 0xff;
2217 arr[15] = (d >> 0) & 0xff;
2218 return array_to_constant(mode, arr);
2219 }
2220 \f
2221 /* branch hint stuff */
2222
2223 /* An array of these is used to propagate hints to predecessor blocks. */
2224 struct spu_bb_info
2225 {
2226 rtx prop_jump; /* propagated from another block */
2227 int bb_index; /* the original block. */
2228 };
2229 static struct spu_bb_info *spu_bb_info;
2230
2231 #define STOP_HINT_P(INSN) \
2232 (GET_CODE(INSN) == CALL_INSN \
2233 || INSN_CODE(INSN) == CODE_FOR_divmodsi4 \
2234 || INSN_CODE(INSN) == CODE_FOR_udivmodsi4)
2235
2236 /* 1 when RTX is a hinted branch or its target. We keep track of
2237 what has been hinted so the safe-hint code can test it easily. */
2238 #define HINTED_P(RTX) \
2239 (RTL_FLAG_CHECK3("HINTED_P", (RTX), CODE_LABEL, JUMP_INSN, CALL_INSN)->unchanging)
2240
2241 /* 1 when RTX is an insn that must be scheduled on an even boundary. */
2242 #define SCHED_ON_EVEN_P(RTX) \
2243 (RTL_FLAG_CHECK2("SCHED_ON_EVEN_P", (RTX), JUMP_INSN, CALL_INSN)->in_struct)
2244
2245 /* Emit a nop for INSN such that the two will dual issue. This assumes
2246 INSN is 8-byte aligned. When INSN is inline asm we emit an lnop.
2247 We check for TImode to handle a MULTI1 insn which has dual issued its
2248 first instruction. get_pipe returns -1 for MULTI0, inline asm, or
2249 ADDR_VEC insns. */
2250 static void
2251 emit_nop_for_insn (rtx insn)
2252 {
2253 int p;
2254 rtx new_insn;
2255 p = get_pipe (insn);
2256 if ((CALL_P (insn) || JUMP_P (insn)) && SCHED_ON_EVEN_P (insn))
2257 new_insn = emit_insn_after (gen_lnop (), insn);
2258 else if (p == 1 && GET_MODE (insn) == TImode)
2259 {
2260 new_insn = emit_insn_before (gen_nopn (GEN_INT (127)), insn);
2261 PUT_MODE (new_insn, TImode);
2262 PUT_MODE (insn, VOIDmode);
2263 }
2264 else
2265 new_insn = emit_insn_after (gen_lnop (), insn);
2266 recog_memoized (new_insn);
2267 }
2268
2269 /* Insert nops in basic blocks to meet dual issue alignment
2270 requirements. Also make sure hbrp and hint instructions are at least
2271 one cycle apart, possibly inserting a nop. */
2272 static void
2273 pad_bb(void)
2274 {
2275 rtx insn, next_insn, prev_insn, hbr_insn = 0;
2276 int length;
2277 int addr;
2278
2279 /* This sets up INSN_ADDRESSES. */
2280 shorten_branches (get_insns ());
2281
2282 /* Keep track of length added by nops. */
2283 length = 0;
2284
2285 prev_insn = 0;
2286 insn = get_insns ();
2287 if (!active_insn_p (insn))
2288 insn = next_active_insn (insn);
2289 for (; insn; insn = next_insn)
2290 {
2291 next_insn = next_active_insn (insn);
2292 if (INSN_CODE (insn) == CODE_FOR_iprefetch
2293 || INSN_CODE (insn) == CODE_FOR_hbr)
2294 {
2295 if (hbr_insn)
2296 {
2297 int a0 = INSN_ADDRESSES (INSN_UID (hbr_insn));
2298 int a1 = INSN_ADDRESSES (INSN_UID (insn));
2299 if ((a1 - a0 == 8 && GET_MODE (insn) != TImode)
2300 || (a1 - a0 == 4))
2301 {
2302 prev_insn = emit_insn_before (gen_lnop (), insn);
2303 PUT_MODE (prev_insn, GET_MODE (insn));
2304 PUT_MODE (insn, TImode);
2305 length += 4;
2306 }
2307 }
2308 hbr_insn = insn;
2309 }
2310 if (INSN_CODE (insn) == CODE_FOR_blockage)
2311 {
2312 if (GET_MODE (insn) == TImode)
2313 PUT_MODE (next_insn, TImode);
2314 insn = next_insn;
2315 next_insn = next_active_insn (insn);
2316 }
2317 addr = INSN_ADDRESSES (INSN_UID (insn));
2318 if ((CALL_P (insn) || JUMP_P (insn)) && SCHED_ON_EVEN_P (insn))
2319 {
2320 if (((addr + length) & 7) != 0)
2321 {
2322 emit_nop_for_insn (prev_insn);
2323 length += 4;
2324 }
2325 }
2326 else if (GET_MODE (insn) == TImode
2327 && ((next_insn && GET_MODE (next_insn) != TImode)
2328 || get_attr_type (insn) == TYPE_MULTI0)
2329 && ((addr + length) & 7) != 0)
2330 {
2331 /* prev_insn will always be set because the first insn is
2332 always 8-byte aligned. */
2333 emit_nop_for_insn (prev_insn);
2334 length += 4;
2335 }
2336 prev_insn = insn;
2337 }
2338 }
2339
2340 \f
2341 /* Routines for branch hints. */
2342
2343 static void
2344 spu_emit_branch_hint (rtx before, rtx branch, rtx target,
2345 int distance, sbitmap blocks)
2346 {
2347 rtx branch_label = 0;
2348 rtx hint;
2349 rtx insn;
2350 rtx table;
2351
2352 if (before == 0 || branch == 0 || target == 0)
2353 return;
2354
2355 /* While scheduling we require hints to be no further than 600, so
2356 we need to enforce that here too */
2357 if (distance > 600)
2358 return;
2359
2360 /* If we have a Basic block note, emit it after the basic block note. */
2361 if (NOTE_INSN_BASIC_BLOCK_P (before))
2362 before = NEXT_INSN (before);
2363
2364 branch_label = gen_label_rtx ();
2365 LABEL_NUSES (branch_label)++;
2366 LABEL_PRESERVE_P (branch_label) = 1;
2367 insn = emit_label_before (branch_label, branch);
2368 branch_label = gen_rtx_LABEL_REF (VOIDmode, branch_label);
2369 SET_BIT (blocks, BLOCK_FOR_INSN (branch)->index);
2370
2371 hint = emit_insn_before (gen_hbr (branch_label, target), before);
2372 recog_memoized (hint);
2373 HINTED_P (branch) = 1;
2374
2375 if (GET_CODE (target) == LABEL_REF)
2376 HINTED_P (XEXP (target, 0)) = 1;
2377 else if (tablejump_p (branch, 0, &table))
2378 {
2379 rtvec vec;
2380 int j;
2381 if (GET_CODE (PATTERN (table)) == ADDR_VEC)
2382 vec = XVEC (PATTERN (table), 0);
2383 else
2384 vec = XVEC (PATTERN (table), 1);
2385 for (j = GET_NUM_ELEM (vec) - 1; j >= 0; --j)
2386 HINTED_P (XEXP (RTVEC_ELT (vec, j), 0)) = 1;
2387 }
2388
2389 if (distance >= 588)
2390 {
2391 /* Make sure the hint isn't scheduled any earlier than this point,
2392 which could make it too far for the branch offest to fit */
2393 recog_memoized (emit_insn_before (gen_blockage (), hint));
2394 }
2395 else if (distance <= 8 * 4)
2396 {
2397 /* To guarantee at least 8 insns between the hint and branch we
2398 insert nops. */
2399 int d;
2400 for (d = distance; d < 8 * 4; d += 4)
2401 {
2402 insn =
2403 emit_insn_after (gen_nopn_nv (gen_rtx_REG (SImode, 127)), hint);
2404 recog_memoized (insn);
2405 }
2406
2407 /* Make sure any nops inserted aren't scheduled before the hint. */
2408 recog_memoized (emit_insn_after (gen_blockage (), hint));
2409
2410 /* Make sure any nops inserted aren't scheduled after the call. */
2411 if (CALL_P (branch) && distance < 8 * 4)
2412 recog_memoized (emit_insn_before (gen_blockage (), branch));
2413 }
2414 }
2415
2416 /* Returns 0 if we don't want a hint for this branch. Otherwise return
2417 the rtx for the branch target. */
2418 static rtx
2419 get_branch_target (rtx branch)
2420 {
2421 if (GET_CODE (branch) == JUMP_INSN)
2422 {
2423 rtx set, src;
2424
2425 /* Return statements */
2426 if (GET_CODE (PATTERN (branch)) == RETURN)
2427 return gen_rtx_REG (SImode, LINK_REGISTER_REGNUM);
2428
2429 /* jump table */
2430 if (GET_CODE (PATTERN (branch)) == ADDR_VEC
2431 || GET_CODE (PATTERN (branch)) == ADDR_DIFF_VEC)
2432 return 0;
2433
2434 /* ASM GOTOs. */
2435 if (extract_asm_operands (PATTERN (branch)) != NULL)
2436 return NULL;
2437
2438 set = single_set (branch);
2439 src = SET_SRC (set);
2440 if (GET_CODE (SET_DEST (set)) != PC)
2441 abort ();
2442
2443 if (GET_CODE (src) == IF_THEN_ELSE)
2444 {
2445 rtx lab = 0;
2446 rtx note = find_reg_note (branch, REG_BR_PROB, 0);
2447 if (note)
2448 {
2449 /* If the more probable case is not a fall through, then
2450 try a branch hint. */
2451 HOST_WIDE_INT prob = INTVAL (XEXP (note, 0));
2452 if (prob > (REG_BR_PROB_BASE * 6 / 10)
2453 && GET_CODE (XEXP (src, 1)) != PC)
2454 lab = XEXP (src, 1);
2455 else if (prob < (REG_BR_PROB_BASE * 4 / 10)
2456 && GET_CODE (XEXP (src, 2)) != PC)
2457 lab = XEXP (src, 2);
2458 }
2459 if (lab)
2460 {
2461 if (GET_CODE (lab) == RETURN)
2462 return gen_rtx_REG (SImode, LINK_REGISTER_REGNUM);
2463 return lab;
2464 }
2465 return 0;
2466 }
2467
2468 return src;
2469 }
2470 else if (GET_CODE (branch) == CALL_INSN)
2471 {
2472 rtx call;
2473 /* All of our call patterns are in a PARALLEL and the CALL is
2474 the first pattern in the PARALLEL. */
2475 if (GET_CODE (PATTERN (branch)) != PARALLEL)
2476 abort ();
2477 call = XVECEXP (PATTERN (branch), 0, 0);
2478 if (GET_CODE (call) == SET)
2479 call = SET_SRC (call);
2480 if (GET_CODE (call) != CALL)
2481 abort ();
2482 return XEXP (XEXP (call, 0), 0);
2483 }
2484 return 0;
2485 }
2486
2487 /* The special $hbr register is used to prevent the insn scheduler from
2488 moving hbr insns across instructions which invalidate them. It
2489 should only be used in a clobber, and this function searches for
2490 insns which clobber it. */
2491 static bool
2492 insn_clobbers_hbr (rtx insn)
2493 {
2494 if (INSN_P (insn)
2495 && GET_CODE (PATTERN (insn)) == PARALLEL)
2496 {
2497 rtx parallel = PATTERN (insn);
2498 rtx clobber;
2499 int j;
2500 for (j = XVECLEN (parallel, 0) - 1; j >= 0; j--)
2501 {
2502 clobber = XVECEXP (parallel, 0, j);
2503 if (GET_CODE (clobber) == CLOBBER
2504 && GET_CODE (XEXP (clobber, 0)) == REG
2505 && REGNO (XEXP (clobber, 0)) == HBR_REGNUM)
2506 return 1;
2507 }
2508 }
2509 return 0;
2510 }
2511
2512 /* Search up to 32 insns starting at FIRST:
2513 - at any kind of hinted branch, just return
2514 - at any unconditional branch in the first 15 insns, just return
2515 - at a call or indirect branch, after the first 15 insns, force it to
2516 an even address and return
2517 - at any unconditional branch, after the first 15 insns, force it to
2518 an even address.
2519 At then end of the search, insert an hbrp within 4 insns of FIRST,
2520 and an hbrp within 16 instructions of FIRST.
2521 */
2522 static void
2523 insert_hbrp_for_ilb_runout (rtx first)
2524 {
2525 rtx insn, before_4 = 0, before_16 = 0;
2526 int addr = 0, length, first_addr = -1;
2527 int hbrp_addr0 = 128 * 4, hbrp_addr1 = 128 * 4;
2528 int insert_lnop_after = 0;
2529 for (insn = first; insn; insn = NEXT_INSN (insn))
2530 if (INSN_P (insn))
2531 {
2532 if (first_addr == -1)
2533 first_addr = INSN_ADDRESSES (INSN_UID (insn));
2534 addr = INSN_ADDRESSES (INSN_UID (insn)) - first_addr;
2535 length = get_attr_length (insn);
2536
2537 if (before_4 == 0 && addr + length >= 4 * 4)
2538 before_4 = insn;
2539 /* We test for 14 instructions because the first hbrp will add
2540 up to 2 instructions. */
2541 if (before_16 == 0 && addr + length >= 14 * 4)
2542 before_16 = insn;
2543
2544 if (INSN_CODE (insn) == CODE_FOR_hbr)
2545 {
2546 /* Make sure an hbrp is at least 2 cycles away from a hint.
2547 Insert an lnop after the hbrp when necessary. */
2548 if (before_4 == 0 && addr > 0)
2549 {
2550 before_4 = insn;
2551 insert_lnop_after |= 1;
2552 }
2553 else if (before_4 && addr <= 4 * 4)
2554 insert_lnop_after |= 1;
2555 if (before_16 == 0 && addr > 10 * 4)
2556 {
2557 before_16 = insn;
2558 insert_lnop_after |= 2;
2559 }
2560 else if (before_16 && addr <= 14 * 4)
2561 insert_lnop_after |= 2;
2562 }
2563
2564 if (INSN_CODE (insn) == CODE_FOR_iprefetch)
2565 {
2566 if (addr < hbrp_addr0)
2567 hbrp_addr0 = addr;
2568 else if (addr < hbrp_addr1)
2569 hbrp_addr1 = addr;
2570 }
2571
2572 if (CALL_P (insn) || JUMP_P (insn))
2573 {
2574 if (HINTED_P (insn))
2575 return;
2576
2577 /* Any branch after the first 15 insns should be on an even
2578 address to avoid a special case branch. There might be
2579 some nops and/or hbrps inserted, so we test after 10
2580 insns. */
2581 if (addr > 10 * 4)
2582 SCHED_ON_EVEN_P (insn) = 1;
2583 }
2584
2585 if (CALL_P (insn) || tablejump_p (insn, 0, 0))
2586 return;
2587
2588
2589 if (addr + length >= 32 * 4)
2590 {
2591 gcc_assert (before_4 && before_16);
2592 if (hbrp_addr0 > 4 * 4)
2593 {
2594 insn =
2595 emit_insn_before (gen_iprefetch (GEN_INT (1)), before_4);
2596 recog_memoized (insn);
2597 INSN_ADDRESSES_NEW (insn,
2598 INSN_ADDRESSES (INSN_UID (before_4)));
2599 PUT_MODE (insn, GET_MODE (before_4));
2600 PUT_MODE (before_4, TImode);
2601 if (insert_lnop_after & 1)
2602 {
2603 insn = emit_insn_before (gen_lnop (), before_4);
2604 recog_memoized (insn);
2605 INSN_ADDRESSES_NEW (insn,
2606 INSN_ADDRESSES (INSN_UID (before_4)));
2607 PUT_MODE (insn, TImode);
2608 }
2609 }
2610 if ((hbrp_addr0 <= 4 * 4 || hbrp_addr0 > 16 * 4)
2611 && hbrp_addr1 > 16 * 4)
2612 {
2613 insn =
2614 emit_insn_before (gen_iprefetch (GEN_INT (2)), before_16);
2615 recog_memoized (insn);
2616 INSN_ADDRESSES_NEW (insn,
2617 INSN_ADDRESSES (INSN_UID (before_16)));
2618 PUT_MODE (insn, GET_MODE (before_16));
2619 PUT_MODE (before_16, TImode);
2620 if (insert_lnop_after & 2)
2621 {
2622 insn = emit_insn_before (gen_lnop (), before_16);
2623 recog_memoized (insn);
2624 INSN_ADDRESSES_NEW (insn,
2625 INSN_ADDRESSES (INSN_UID
2626 (before_16)));
2627 PUT_MODE (insn, TImode);
2628 }
2629 }
2630 return;
2631 }
2632 }
2633 else if (BARRIER_P (insn))
2634 return;
2635
2636 }
2637
2638 /* The SPU might hang when it executes 48 inline instructions after a
2639 hinted branch jumps to its hinted target. The beginning of a
2640 function and the return from a call might have been hinted, and must
2641 be handled as well. To prevent a hang we insert 2 hbrps. The first
2642 should be within 6 insns of the branch target. The second should be
2643 within 22 insns of the branch target. When determining if hbrps are
2644 necessary, we look for only 32 inline instructions, because up to to
2645 12 nops and 4 hbrps could be inserted. Similarily, when inserting
2646 new hbrps, we insert them within 4 and 16 insns of the target. */
2647 static void
2648 insert_hbrp (void)
2649 {
2650 rtx insn;
2651 if (TARGET_SAFE_HINTS)
2652 {
2653 shorten_branches (get_insns ());
2654 /* Insert hbrp at beginning of function */
2655 insn = next_active_insn (get_insns ());
2656 if (insn)
2657 insert_hbrp_for_ilb_runout (insn);
2658 /* Insert hbrp after hinted targets. */
2659 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2660 if ((LABEL_P (insn) && HINTED_P (insn)) || CALL_P (insn))
2661 insert_hbrp_for_ilb_runout (next_active_insn (insn));
2662 }
2663 }
2664
2665 static int in_spu_reorg;
2666
2667 /* Insert branch hints. There are no branch optimizations after this
2668 pass, so it's safe to set our branch hints now. */
2669 static void
2670 spu_machine_dependent_reorg (void)
2671 {
2672 sbitmap blocks;
2673 basic_block bb;
2674 rtx branch, insn;
2675 rtx branch_target = 0;
2676 int branch_addr = 0, insn_addr, required_dist = 0;
2677 int i;
2678 unsigned int j;
2679
2680 if (!TARGET_BRANCH_HINTS || optimize == 0)
2681 {
2682 /* We still do it for unoptimized code because an external
2683 function might have hinted a call or return. */
2684 insert_hbrp ();
2685 pad_bb ();
2686 return;
2687 }
2688
2689 blocks = sbitmap_alloc (last_basic_block);
2690 sbitmap_zero (blocks);
2691
2692 in_spu_reorg = 1;
2693 compute_bb_for_insn ();
2694
2695 compact_blocks ();
2696
2697 spu_bb_info =
2698 (struct spu_bb_info *) xcalloc (n_basic_blocks,
2699 sizeof (struct spu_bb_info));
2700
2701 /* We need exact insn addresses and lengths. */
2702 shorten_branches (get_insns ());
2703
2704 for (i = n_basic_blocks - 1; i >= 0; i--)
2705 {
2706 bb = BASIC_BLOCK (i);
2707 branch = 0;
2708 if (spu_bb_info[i].prop_jump)
2709 {
2710 branch = spu_bb_info[i].prop_jump;
2711 branch_target = get_branch_target (branch);
2712 branch_addr = INSN_ADDRESSES (INSN_UID (branch));
2713 required_dist = spu_hint_dist;
2714 }
2715 /* Search from end of a block to beginning. In this loop, find
2716 jumps which need a branch and emit them only when:
2717 - it's an indirect branch and we're at the insn which sets
2718 the register
2719 - we're at an insn that will invalidate the hint. e.g., a
2720 call, another hint insn, inline asm that clobbers $hbr, and
2721 some inlined operations (divmodsi4). Don't consider jumps
2722 because they are only at the end of a block and are
2723 considered when we are deciding whether to propagate
2724 - we're getting too far away from the branch. The hbr insns
2725 only have a signed 10 bit offset
2726 We go back as far as possible so the branch will be considered
2727 for propagation when we get to the beginning of the block. */
2728 for (insn = BB_END (bb); insn; insn = PREV_INSN (insn))
2729 {
2730 if (INSN_P (insn))
2731 {
2732 insn_addr = INSN_ADDRESSES (INSN_UID (insn));
2733 if (branch
2734 && ((GET_CODE (branch_target) == REG
2735 && set_of (branch_target, insn) != NULL_RTX)
2736 || insn_clobbers_hbr (insn)
2737 || branch_addr - insn_addr > 600))
2738 {
2739 rtx next = NEXT_INSN (insn);
2740 int next_addr = INSN_ADDRESSES (INSN_UID (next));
2741 if (insn != BB_END (bb)
2742 && branch_addr - next_addr >= required_dist)
2743 {
2744 if (dump_file)
2745 fprintf (dump_file,
2746 "hint for %i in block %i before %i\n",
2747 INSN_UID (branch), bb->index,
2748 INSN_UID (next));
2749 spu_emit_branch_hint (next, branch, branch_target,
2750 branch_addr - next_addr, blocks);
2751 }
2752 branch = 0;
2753 }
2754
2755 /* JUMP_P will only be true at the end of a block. When
2756 branch is already set it means we've previously decided
2757 to propagate a hint for that branch into this block. */
2758 if (CALL_P (insn) || (JUMP_P (insn) && !branch))
2759 {
2760 branch = 0;
2761 if ((branch_target = get_branch_target (insn)))
2762 {
2763 branch = insn;
2764 branch_addr = insn_addr;
2765 required_dist = spu_hint_dist;
2766 }
2767 }
2768 }
2769 if (insn == BB_HEAD (bb))
2770 break;
2771 }
2772
2773 if (branch)
2774 {
2775 /* If we haven't emitted a hint for this branch yet, it might
2776 be profitable to emit it in one of the predecessor blocks,
2777 especially for loops. */
2778 rtx bbend;
2779 basic_block prev = 0, prop = 0, prev2 = 0;
2780 int loop_exit = 0, simple_loop = 0;
2781 int next_addr = INSN_ADDRESSES (INSN_UID (NEXT_INSN (insn)));
2782
2783 for (j = 0; j < EDGE_COUNT (bb->preds); j++)
2784 if (EDGE_PRED (bb, j)->flags & EDGE_FALLTHRU)
2785 prev = EDGE_PRED (bb, j)->src;
2786 else
2787 prev2 = EDGE_PRED (bb, j)->src;
2788
2789 for (j = 0; j < EDGE_COUNT (bb->succs); j++)
2790 if (EDGE_SUCC (bb, j)->flags & EDGE_LOOP_EXIT)
2791 loop_exit = 1;
2792 else if (EDGE_SUCC (bb, j)->dest == bb)
2793 simple_loop = 1;
2794
2795 /* If this branch is a loop exit then propagate to previous
2796 fallthru block. This catches the cases when it is a simple
2797 loop or when there is an initial branch into the loop. */
2798 if (prev && (loop_exit || simple_loop)
2799 && prev->loop_depth <= bb->loop_depth)
2800 prop = prev;
2801
2802 /* If there is only one adjacent predecessor. Don't propagate
2803 outside this loop. This loop_depth test isn't perfect, but
2804 I'm not sure the loop_father member is valid at this point. */
2805 else if (prev && single_pred_p (bb)
2806 && prev->loop_depth == bb->loop_depth)
2807 prop = prev;
2808
2809 /* If this is the JOIN block of a simple IF-THEN then
2810 propogate the hint to the HEADER block. */
2811 else if (prev && prev2
2812 && EDGE_COUNT (bb->preds) == 2
2813 && EDGE_COUNT (prev->preds) == 1
2814 && EDGE_PRED (prev, 0)->src == prev2
2815 && prev2->loop_depth == bb->loop_depth
2816 && GET_CODE (branch_target) != REG)
2817 prop = prev;
2818
2819 /* Don't propagate when:
2820 - this is a simple loop and the hint would be too far
2821 - this is not a simple loop and there are 16 insns in
2822 this block already
2823 - the predecessor block ends in a branch that will be
2824 hinted
2825 - the predecessor block ends in an insn that invalidates
2826 the hint */
2827 if (prop
2828 && prop->index >= 0
2829 && (bbend = BB_END (prop))
2830 && branch_addr - INSN_ADDRESSES (INSN_UID (bbend)) <
2831 (simple_loop ? 600 : 16 * 4) && get_branch_target (bbend) == 0
2832 && (JUMP_P (bbend) || !insn_clobbers_hbr (bbend)))
2833 {
2834 if (dump_file)
2835 fprintf (dump_file, "propagate from %i to %i (loop depth %i) "
2836 "for %i (loop_exit %i simple_loop %i dist %i)\n",
2837 bb->index, prop->index, bb->loop_depth,
2838 INSN_UID (branch), loop_exit, simple_loop,
2839 branch_addr - INSN_ADDRESSES (INSN_UID (bbend)));
2840
2841 spu_bb_info[prop->index].prop_jump = branch;
2842 spu_bb_info[prop->index].bb_index = i;
2843 }
2844 else if (branch_addr - next_addr >= required_dist)
2845 {
2846 if (dump_file)
2847 fprintf (dump_file, "hint for %i in block %i before %i\n",
2848 INSN_UID (branch), bb->index,
2849 INSN_UID (NEXT_INSN (insn)));
2850 spu_emit_branch_hint (NEXT_INSN (insn), branch, branch_target,
2851 branch_addr - next_addr, blocks);
2852 }
2853 branch = 0;
2854 }
2855 }
2856 free (spu_bb_info);
2857
2858 if (!sbitmap_empty_p (blocks))
2859 find_many_sub_basic_blocks (blocks);
2860
2861 /* We have to schedule to make sure alignment is ok. */
2862 FOR_EACH_BB (bb) bb->flags &= ~BB_DISABLE_SCHEDULE;
2863
2864 /* The hints need to be scheduled, so call it again. */
2865 schedule_insns ();
2866
2867 insert_hbrp ();
2868
2869 pad_bb ();
2870
2871 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2872 if (NONJUMP_INSN_P (insn) && INSN_CODE (insn) == CODE_FOR_hbr)
2873 {
2874 /* Adjust the LABEL_REF in a hint when we have inserted a nop
2875 between its branch label and the branch . We don't move the
2876 label because GCC expects it at the beginning of the block. */
2877 rtx unspec = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2878 rtx label_ref = XVECEXP (unspec, 0, 0);
2879 rtx label = XEXP (label_ref, 0);
2880 rtx branch;
2881 int offset = 0;
2882 for (branch = NEXT_INSN (label);
2883 !JUMP_P (branch) && !CALL_P (branch);
2884 branch = NEXT_INSN (branch))
2885 if (NONJUMP_INSN_P (branch))
2886 offset += get_attr_length (branch);
2887 if (offset > 0)
2888 XVECEXP (unspec, 0, 0) = plus_constant (label_ref, offset);
2889 }
2890
2891 if (spu_flag_var_tracking)
2892 {
2893 df_analyze ();
2894 timevar_push (TV_VAR_TRACKING);
2895 variable_tracking_main ();
2896 timevar_pop (TV_VAR_TRACKING);
2897 df_finish_pass (false);
2898 }
2899
2900 free_bb_for_insn ();
2901
2902 in_spu_reorg = 0;
2903 }
2904 \f
2905
2906 /* Insn scheduling routines, primarily for dual issue. */
2907 static int
2908 spu_sched_issue_rate (void)
2909 {
2910 return 2;
2911 }
2912
2913 static int
2914 uses_ls_unit(rtx insn)
2915 {
2916 rtx set = single_set (insn);
2917 if (set != 0
2918 && (GET_CODE (SET_DEST (set)) == MEM
2919 || GET_CODE (SET_SRC (set)) == MEM))
2920 return 1;
2921 return 0;
2922 }
2923
2924 static int
2925 get_pipe (rtx insn)
2926 {
2927 enum attr_type t;
2928 /* Handle inline asm */
2929 if (INSN_CODE (insn) == -1)
2930 return -1;
2931 t = get_attr_type (insn);
2932 switch (t)
2933 {
2934 case TYPE_CONVERT:
2935 return -2;
2936 case TYPE_MULTI0:
2937 return -1;
2938
2939 case TYPE_FX2:
2940 case TYPE_FX3:
2941 case TYPE_SPR:
2942 case TYPE_NOP:
2943 case TYPE_FXB:
2944 case TYPE_FPD:
2945 case TYPE_FP6:
2946 case TYPE_FP7:
2947 return 0;
2948
2949 case TYPE_LNOP:
2950 case TYPE_SHUF:
2951 case TYPE_LOAD:
2952 case TYPE_STORE:
2953 case TYPE_BR:
2954 case TYPE_MULTI1:
2955 case TYPE_HBR:
2956 case TYPE_IPREFETCH:
2957 return 1;
2958 default:
2959 abort ();
2960 }
2961 }
2962
2963
2964 /* haifa-sched.c has a static variable that keeps track of the current
2965 cycle. It is passed to spu_sched_reorder, and we record it here for
2966 use by spu_sched_variable_issue. It won't be accurate if the
2967 scheduler updates it's clock_var between the two calls. */
2968 static int clock_var;
2969
2970 /* This is used to keep track of insn alignment. Set to 0 at the
2971 beginning of each block and increased by the "length" attr of each
2972 insn scheduled. */
2973 static int spu_sched_length;
2974
2975 /* Record when we've issued pipe0 and pipe1 insns so we can reorder the
2976 ready list appropriately in spu_sched_reorder(). */
2977 static int pipe0_clock;
2978 static int pipe1_clock;
2979
2980 static int prev_clock_var;
2981
2982 static int prev_priority;
2983
2984 /* The SPU needs to load the next ilb sometime during the execution of
2985 the previous ilb. There is a potential conflict if every cycle has a
2986 load or store. To avoid the conflict we make sure the load/store
2987 unit is free for at least one cycle during the execution of insns in
2988 the previous ilb. */
2989 static int spu_ls_first;
2990 static int prev_ls_clock;
2991
2992 static void
2993 spu_sched_init_global (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
2994 int max_ready ATTRIBUTE_UNUSED)
2995 {
2996 spu_sched_length = 0;
2997 }
2998
2999 static void
3000 spu_sched_init (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
3001 int max_ready ATTRIBUTE_UNUSED)
3002 {
3003 if (align_labels > 4 || align_loops > 4 || align_jumps > 4)
3004 {
3005 /* When any block might be at least 8-byte aligned, assume they
3006 will all be at least 8-byte aligned to make sure dual issue
3007 works out correctly. */
3008 spu_sched_length = 0;
3009 }
3010 spu_ls_first = INT_MAX;
3011 clock_var = -1;
3012 prev_ls_clock = -1;
3013 pipe0_clock = -1;
3014 pipe1_clock = -1;
3015 prev_clock_var = -1;
3016 prev_priority = -1;
3017 }
3018
3019 static int
3020 spu_sched_variable_issue (FILE *file ATTRIBUTE_UNUSED,
3021 int verbose ATTRIBUTE_UNUSED, rtx insn, int more)
3022 {
3023 int len;
3024 int p;
3025 if (GET_CODE (PATTERN (insn)) == USE
3026 || GET_CODE (PATTERN (insn)) == CLOBBER
3027 || (len = get_attr_length (insn)) == 0)
3028 return more;
3029
3030 spu_sched_length += len;
3031
3032 /* Reset on inline asm */
3033 if (INSN_CODE (insn) == -1)
3034 {
3035 spu_ls_first = INT_MAX;
3036 pipe0_clock = -1;
3037 pipe1_clock = -1;
3038 return 0;
3039 }
3040 p = get_pipe (insn);
3041 if (p == 0)
3042 pipe0_clock = clock_var;
3043 else
3044 pipe1_clock = clock_var;
3045
3046 if (in_spu_reorg)
3047 {
3048 if (clock_var - prev_ls_clock > 1
3049 || INSN_CODE (insn) == CODE_FOR_iprefetch)
3050 spu_ls_first = INT_MAX;
3051 if (uses_ls_unit (insn))
3052 {
3053 if (spu_ls_first == INT_MAX)
3054 spu_ls_first = spu_sched_length;
3055 prev_ls_clock = clock_var;
3056 }
3057
3058 /* The scheduler hasn't inserted the nop, but we will later on.
3059 Include those nops in spu_sched_length. */
3060 if (prev_clock_var == clock_var && (spu_sched_length & 7))
3061 spu_sched_length += 4;
3062 prev_clock_var = clock_var;
3063
3064 /* more is -1 when called from spu_sched_reorder for new insns
3065 that don't have INSN_PRIORITY */
3066 if (more >= 0)
3067 prev_priority = INSN_PRIORITY (insn);
3068 }
3069
3070 /* Always try issueing more insns. spu_sched_reorder will decide
3071 when the cycle should be advanced. */
3072 return 1;
3073 }
3074
3075 /* This function is called for both TARGET_SCHED_REORDER and
3076 TARGET_SCHED_REORDER2. */
3077 static int
3078 spu_sched_reorder (FILE *file ATTRIBUTE_UNUSED, int verbose ATTRIBUTE_UNUSED,
3079 rtx *ready, int *nreadyp, int clock)
3080 {
3081 int i, nready = *nreadyp;
3082 int pipe_0, pipe_1, pipe_hbrp, pipe_ls, schedule_i;
3083 rtx insn;
3084
3085 clock_var = clock;
3086
3087 if (nready <= 0 || pipe1_clock >= clock)
3088 return 0;
3089
3090 /* Find any rtl insns that don't generate assembly insns and schedule
3091 them first. */
3092 for (i = nready - 1; i >= 0; i--)
3093 {
3094 insn = ready[i];
3095 if (INSN_CODE (insn) == -1
3096 || INSN_CODE (insn) == CODE_FOR_blockage
3097 || (INSN_P (insn) && get_attr_length (insn) == 0))
3098 {
3099 ready[i] = ready[nready - 1];
3100 ready[nready - 1] = insn;
3101 return 1;
3102 }
3103 }
3104
3105 pipe_0 = pipe_1 = pipe_hbrp = pipe_ls = schedule_i = -1;
3106 for (i = 0; i < nready; i++)
3107 if (INSN_CODE (ready[i]) != -1)
3108 {
3109 insn = ready[i];
3110 switch (get_attr_type (insn))
3111 {
3112 default:
3113 case TYPE_MULTI0:
3114 case TYPE_CONVERT:
3115 case TYPE_FX2:
3116 case TYPE_FX3:
3117 case TYPE_SPR:
3118 case TYPE_NOP:
3119 case TYPE_FXB:
3120 case TYPE_FPD:
3121 case TYPE_FP6:
3122 case TYPE_FP7:
3123 pipe_0 = i;
3124 break;
3125 case TYPE_LOAD:
3126 case TYPE_STORE:
3127 pipe_ls = i;
3128 case TYPE_LNOP:
3129 case TYPE_SHUF:
3130 case TYPE_BR:
3131 case TYPE_MULTI1:
3132 case TYPE_HBR:
3133 pipe_1 = i;
3134 break;
3135 case TYPE_IPREFETCH:
3136 pipe_hbrp = i;
3137 break;
3138 }
3139 }
3140
3141 /* In the first scheduling phase, schedule loads and stores together
3142 to increase the chance they will get merged during postreload CSE. */
3143 if (!reload_completed && pipe_ls >= 0)
3144 {
3145 insn = ready[pipe_ls];
3146 ready[pipe_ls] = ready[nready - 1];
3147 ready[nready - 1] = insn;
3148 return 1;
3149 }
3150
3151 /* If there is an hbrp ready, prefer it over other pipe 1 insns. */
3152 if (pipe_hbrp >= 0)
3153 pipe_1 = pipe_hbrp;
3154
3155 /* When we have loads/stores in every cycle of the last 15 insns and
3156 we are about to schedule another load/store, emit an hbrp insn
3157 instead. */
3158 if (in_spu_reorg
3159 && spu_sched_length - spu_ls_first >= 4 * 15
3160 && !(pipe0_clock < clock && pipe_0 >= 0) && pipe_1 == pipe_ls)
3161 {
3162 insn = sched_emit_insn (gen_iprefetch (GEN_INT (3)));
3163 recog_memoized (insn);
3164 if (pipe0_clock < clock)
3165 PUT_MODE (insn, TImode);
3166 spu_sched_variable_issue (file, verbose, insn, -1);
3167 return 0;
3168 }
3169
3170 /* In general, we want to emit nops to increase dual issue, but dual
3171 issue isn't faster when one of the insns could be scheduled later
3172 without effecting the critical path. We look at INSN_PRIORITY to
3173 make a good guess, but it isn't perfect so -mdual-nops=n can be
3174 used to effect it. */
3175 if (in_spu_reorg && spu_dual_nops < 10)
3176 {
3177 /* When we are at an even address and we are not issueing nops to
3178 improve scheduling then we need to advance the cycle. */
3179 if ((spu_sched_length & 7) == 0 && prev_clock_var == clock
3180 && (spu_dual_nops == 0
3181 || (pipe_1 != -1
3182 && prev_priority >
3183 INSN_PRIORITY (ready[pipe_1]) + spu_dual_nops)))
3184 return 0;
3185
3186 /* When at an odd address, schedule the highest priority insn
3187 without considering pipeline. */
3188 if ((spu_sched_length & 7) == 4 && prev_clock_var != clock
3189 && (spu_dual_nops == 0
3190 || (prev_priority >
3191 INSN_PRIORITY (ready[nready - 1]) + spu_dual_nops)))
3192 return 1;
3193 }
3194
3195
3196 /* We haven't issued a pipe0 insn yet this cycle, if there is a
3197 pipe0 insn in the ready list, schedule it. */
3198 if (pipe0_clock < clock && pipe_0 >= 0)
3199 schedule_i = pipe_0;
3200
3201 /* Either we've scheduled a pipe0 insn already or there is no pipe0
3202 insn to schedule. Put a pipe1 insn at the front of the ready list. */
3203 else
3204 schedule_i = pipe_1;
3205
3206 if (schedule_i > -1)
3207 {
3208 insn = ready[schedule_i];
3209 ready[schedule_i] = ready[nready - 1];
3210 ready[nready - 1] = insn;
3211 return 1;
3212 }
3213 return 0;
3214 }
3215
3216 /* INSN is dependent on DEP_INSN. */
3217 static int
3218 spu_sched_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
3219 {
3220 rtx set;
3221
3222 /* The blockage pattern is used to prevent instructions from being
3223 moved across it and has no cost. */
3224 if (INSN_CODE (insn) == CODE_FOR_blockage
3225 || INSN_CODE (dep_insn) == CODE_FOR_blockage)
3226 return 0;
3227
3228 if ((INSN_P (insn) && get_attr_length (insn) == 0)
3229 || (INSN_P (dep_insn) && get_attr_length (dep_insn) == 0))
3230 return 0;
3231
3232 /* Make sure hbrps are spread out. */
3233 if (INSN_CODE (insn) == CODE_FOR_iprefetch
3234 && INSN_CODE (dep_insn) == CODE_FOR_iprefetch)
3235 return 8;
3236
3237 /* Make sure hints and hbrps are 2 cycles apart. */
3238 if ((INSN_CODE (insn) == CODE_FOR_iprefetch
3239 || INSN_CODE (insn) == CODE_FOR_hbr)
3240 && (INSN_CODE (dep_insn) == CODE_FOR_iprefetch
3241 || INSN_CODE (dep_insn) == CODE_FOR_hbr))
3242 return 2;
3243
3244 /* An hbrp has no real dependency on other insns. */
3245 if (INSN_CODE (insn) == CODE_FOR_iprefetch
3246 || INSN_CODE (dep_insn) == CODE_FOR_iprefetch)
3247 return 0;
3248
3249 /* Assuming that it is unlikely an argument register will be used in
3250 the first cycle of the called function, we reduce the cost for
3251 slightly better scheduling of dep_insn. When not hinted, the
3252 mispredicted branch would hide the cost as well. */
3253 if (CALL_P (insn))
3254 {
3255 rtx target = get_branch_target (insn);
3256 if (GET_CODE (target) != REG || !set_of (target, insn))
3257 return cost - 2;
3258 return cost;
3259 }
3260
3261 /* And when returning from a function, let's assume the return values
3262 are completed sooner too. */
3263 if (CALL_P (dep_insn))
3264 return cost - 2;
3265
3266 /* Make sure an instruction that loads from the back chain is schedule
3267 away from the return instruction so a hint is more likely to get
3268 issued. */
3269 if (INSN_CODE (insn) == CODE_FOR__return
3270 && (set = single_set (dep_insn))
3271 && GET_CODE (SET_DEST (set)) == REG
3272 && REGNO (SET_DEST (set)) == LINK_REGISTER_REGNUM)
3273 return 20;
3274
3275 /* The dfa scheduler sets cost to 0 for all anti-dependencies and the
3276 scheduler makes every insn in a block anti-dependent on the final
3277 jump_insn. We adjust here so higher cost insns will get scheduled
3278 earlier. */
3279 if (JUMP_P (insn) && REG_NOTE_KIND (link) == REG_DEP_ANTI)
3280 return insn_cost (dep_insn) - 3;
3281
3282 return cost;
3283 }
3284 \f
3285 /* Create a CONST_DOUBLE from a string. */
3286 struct rtx_def *
3287 spu_float_const (const char *string, enum machine_mode mode)
3288 {
3289 REAL_VALUE_TYPE value;
3290 value = REAL_VALUE_ATOF (string, mode);
3291 return CONST_DOUBLE_FROM_REAL_VALUE (value, mode);
3292 }
3293
3294 int
3295 spu_constant_address_p (rtx x)
3296 {
3297 return (GET_CODE (x) == LABEL_REF || GET_CODE (x) == SYMBOL_REF
3298 || GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST
3299 || GET_CODE (x) == HIGH);
3300 }
3301
3302 static enum spu_immediate
3303 which_immediate_load (HOST_WIDE_INT val)
3304 {
3305 gcc_assert (val == trunc_int_for_mode (val, SImode));
3306
3307 if (val >= -0x8000 && val <= 0x7fff)
3308 return SPU_IL;
3309 if (val >= 0 && val <= 0x3ffff)
3310 return SPU_ILA;
3311 if ((val & 0xffff) == ((val >> 16) & 0xffff))
3312 return SPU_ILH;
3313 if ((val & 0xffff) == 0)
3314 return SPU_ILHU;
3315
3316 return SPU_NONE;
3317 }
3318
3319 /* Return true when OP can be loaded by one of the il instructions, or
3320 when flow2 is not completed and OP can be loaded using ilhu and iohl. */
3321 int
3322 immediate_load_p (rtx op, enum machine_mode mode)
3323 {
3324 if (CONSTANT_P (op))
3325 {
3326 enum immediate_class c = classify_immediate (op, mode);
3327 return c == IC_IL1 || c == IC_IL1s
3328 || (!epilogue_completed && (c == IC_IL2 || c == IC_IL2s));
3329 }
3330 return 0;
3331 }
3332
3333 /* Return true if the first SIZE bytes of arr is a constant that can be
3334 generated with cbd, chd, cwd or cdd. When non-NULL, PRUN and PSTART
3335 represent the size and offset of the instruction to use. */
3336 static int
3337 cpat_info(unsigned char *arr, int size, int *prun, int *pstart)
3338 {
3339 int cpat, run, i, start;
3340 cpat = 1;
3341 run = 0;
3342 start = -1;
3343 for (i = 0; i < size && cpat; i++)
3344 if (arr[i] != i+16)
3345 {
3346 if (!run)
3347 {
3348 start = i;
3349 if (arr[i] == 3)
3350 run = 1;
3351 else if (arr[i] == 2 && arr[i+1] == 3)
3352 run = 2;
3353 else if (arr[i] == 0)
3354 {
3355 while (arr[i+run] == run && i+run < 16)
3356 run++;
3357 if (run != 4 && run != 8)
3358 cpat = 0;
3359 }
3360 else
3361 cpat = 0;
3362 if ((i & (run-1)) != 0)
3363 cpat = 0;
3364 i += run;
3365 }
3366 else
3367 cpat = 0;
3368 }
3369 if (cpat && (run || size < 16))
3370 {
3371 if (run == 0)
3372 run = 1;
3373 if (prun)
3374 *prun = run;
3375 if (pstart)
3376 *pstart = start == -1 ? 16-run : start;
3377 return 1;
3378 }
3379 return 0;
3380 }
3381
3382 /* OP is a CONSTANT_P. Determine what instructions can be used to load
3383 it into a register. MODE is only valid when OP is a CONST_INT. */
3384 static enum immediate_class
3385 classify_immediate (rtx op, enum machine_mode mode)
3386 {
3387 HOST_WIDE_INT val;
3388 unsigned char arr[16];
3389 int i, j, repeated, fsmbi, repeat;
3390
3391 gcc_assert (CONSTANT_P (op));
3392
3393 if (GET_MODE (op) != VOIDmode)
3394 mode = GET_MODE (op);
3395
3396 /* A V4SI const_vector with all identical symbols is ok. */
3397 if (!flag_pic
3398 && mode == V4SImode
3399 && GET_CODE (op) == CONST_VECTOR
3400 && GET_CODE (CONST_VECTOR_ELT (op, 0)) != CONST_INT
3401 && GET_CODE (CONST_VECTOR_ELT (op, 0)) != CONST_DOUBLE
3402 && CONST_VECTOR_ELT (op, 0) == CONST_VECTOR_ELT (op, 1)
3403 && CONST_VECTOR_ELT (op, 1) == CONST_VECTOR_ELT (op, 2)
3404 && CONST_VECTOR_ELT (op, 2) == CONST_VECTOR_ELT (op, 3))
3405 op = CONST_VECTOR_ELT (op, 0);
3406
3407 switch (GET_CODE (op))
3408 {
3409 case SYMBOL_REF:
3410 case LABEL_REF:
3411 return TARGET_LARGE_MEM ? IC_IL2s : IC_IL1s;
3412
3413 case CONST:
3414 /* We can never know if the resulting address fits in 18 bits and can be
3415 loaded with ila. For now, assume the address will not overflow if
3416 the displacement is "small" (fits 'K' constraint). */
3417 if (!TARGET_LARGE_MEM && GET_CODE (XEXP (op, 0)) == PLUS)
3418 {
3419 rtx sym = XEXP (XEXP (op, 0), 0);
3420 rtx cst = XEXP (XEXP (op, 0), 1);
3421
3422 if (GET_CODE (sym) == SYMBOL_REF
3423 && GET_CODE (cst) == CONST_INT
3424 && satisfies_constraint_K (cst))
3425 return IC_IL1s;
3426 }
3427 return IC_IL2s;
3428
3429 case HIGH:
3430 return IC_IL1s;
3431
3432 case CONST_VECTOR:
3433 for (i = 0; i < GET_MODE_NUNITS (mode); i++)
3434 if (GET_CODE (CONST_VECTOR_ELT (op, i)) != CONST_INT
3435 && GET_CODE (CONST_VECTOR_ELT (op, i)) != CONST_DOUBLE)
3436 return IC_POOL;
3437 /* Fall through. */
3438
3439 case CONST_INT:
3440 case CONST_DOUBLE:
3441 constant_to_array (mode, op, arr);
3442
3443 /* Check that each 4-byte slot is identical. */
3444 repeated = 1;
3445 for (i = 4; i < 16; i += 4)
3446 for (j = 0; j < 4; j++)
3447 if (arr[j] != arr[i + j])
3448 repeated = 0;
3449
3450 if (repeated)
3451 {
3452 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
3453 val = trunc_int_for_mode (val, SImode);
3454
3455 if (which_immediate_load (val) != SPU_NONE)
3456 return IC_IL1;
3457 }
3458
3459 /* Any mode of 2 bytes or smaller can be loaded with an il
3460 instruction. */
3461 gcc_assert (GET_MODE_SIZE (mode) > 2);
3462
3463 fsmbi = 1;
3464 repeat = 0;
3465 for (i = 0; i < 16 && fsmbi; i++)
3466 if (arr[i] != 0 && repeat == 0)
3467 repeat = arr[i];
3468 else if (arr[i] != 0 && arr[i] != repeat)
3469 fsmbi = 0;
3470 if (fsmbi)
3471 return repeat == 0xff ? IC_FSMBI : IC_FSMBI2;
3472
3473 if (cpat_info (arr, GET_MODE_SIZE (mode), 0, 0))
3474 return IC_CPAT;
3475
3476 if (repeated)
3477 return IC_IL2;
3478
3479 return IC_POOL;
3480 default:
3481 break;
3482 }
3483 gcc_unreachable ();
3484 }
3485
3486 static enum spu_immediate
3487 which_logical_immediate (HOST_WIDE_INT val)
3488 {
3489 gcc_assert (val == trunc_int_for_mode (val, SImode));
3490
3491 if (val >= -0x200 && val <= 0x1ff)
3492 return SPU_ORI;
3493 if (val >= 0 && val <= 0xffff)
3494 return SPU_IOHL;
3495 if ((val & 0xffff) == ((val >> 16) & 0xffff))
3496 {
3497 val = trunc_int_for_mode (val, HImode);
3498 if (val >= -0x200 && val <= 0x1ff)
3499 return SPU_ORHI;
3500 if ((val & 0xff) == ((val >> 8) & 0xff))
3501 {
3502 val = trunc_int_for_mode (val, QImode);
3503 if (val >= -0x200 && val <= 0x1ff)
3504 return SPU_ORBI;
3505 }
3506 }
3507 return SPU_NONE;
3508 }
3509
3510 /* Return TRUE when X, a CONST_VECTOR, only contains CONST_INTs or
3511 CONST_DOUBLEs. */
3512 static int
3513 const_vector_immediate_p (rtx x)
3514 {
3515 int i;
3516 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3517 for (i = 0; i < GET_MODE_NUNITS (GET_MODE (x)); i++)
3518 if (GET_CODE (CONST_VECTOR_ELT (x, i)) != CONST_INT
3519 && GET_CODE (CONST_VECTOR_ELT (x, i)) != CONST_DOUBLE)
3520 return 0;
3521 return 1;
3522 }
3523
3524 int
3525 logical_immediate_p (rtx op, enum machine_mode mode)
3526 {
3527 HOST_WIDE_INT val;
3528 unsigned char arr[16];
3529 int i, j;
3530
3531 gcc_assert (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
3532 || GET_CODE (op) == CONST_VECTOR);
3533
3534 if (GET_CODE (op) == CONST_VECTOR
3535 && !const_vector_immediate_p (op))
3536 return 0;
3537
3538 if (GET_MODE (op) != VOIDmode)
3539 mode = GET_MODE (op);
3540
3541 constant_to_array (mode, op, arr);
3542
3543 /* Check that bytes are repeated. */
3544 for (i = 4; i < 16; i += 4)
3545 for (j = 0; j < 4; j++)
3546 if (arr[j] != arr[i + j])
3547 return 0;
3548
3549 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
3550 val = trunc_int_for_mode (val, SImode);
3551
3552 i = which_logical_immediate (val);
3553 return i != SPU_NONE && i != SPU_IOHL;
3554 }
3555
3556 int
3557 iohl_immediate_p (rtx op, enum machine_mode mode)
3558 {
3559 HOST_WIDE_INT val;
3560 unsigned char arr[16];
3561 int i, j;
3562
3563 gcc_assert (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
3564 || GET_CODE (op) == CONST_VECTOR);
3565
3566 if (GET_CODE (op) == CONST_VECTOR
3567 && !const_vector_immediate_p (op))
3568 return 0;
3569
3570 if (GET_MODE (op) != VOIDmode)
3571 mode = GET_MODE (op);
3572
3573 constant_to_array (mode, op, arr);
3574
3575 /* Check that bytes are repeated. */
3576 for (i = 4; i < 16; i += 4)
3577 for (j = 0; j < 4; j++)
3578 if (arr[j] != arr[i + j])
3579 return 0;
3580
3581 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
3582 val = trunc_int_for_mode (val, SImode);
3583
3584 return val >= 0 && val <= 0xffff;
3585 }
3586
3587 int
3588 arith_immediate_p (rtx op, enum machine_mode mode,
3589 HOST_WIDE_INT low, HOST_WIDE_INT high)
3590 {
3591 HOST_WIDE_INT val;
3592 unsigned char arr[16];
3593 int bytes, i, j;
3594
3595 gcc_assert (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
3596 || GET_CODE (op) == CONST_VECTOR);
3597
3598 if (GET_CODE (op) == CONST_VECTOR
3599 && !const_vector_immediate_p (op))
3600 return 0;
3601
3602 if (GET_MODE (op) != VOIDmode)
3603 mode = GET_MODE (op);
3604
3605 constant_to_array (mode, op, arr);
3606
3607 if (VECTOR_MODE_P (mode))
3608 mode = GET_MODE_INNER (mode);
3609
3610 bytes = GET_MODE_SIZE (mode);
3611 mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
3612
3613 /* Check that bytes are repeated. */
3614 for (i = bytes; i < 16; i += bytes)
3615 for (j = 0; j < bytes; j++)
3616 if (arr[j] != arr[i + j])
3617 return 0;
3618
3619 val = arr[0];
3620 for (j = 1; j < bytes; j++)
3621 val = (val << 8) | arr[j];
3622
3623 val = trunc_int_for_mode (val, mode);
3624
3625 return val >= low && val <= high;
3626 }
3627
3628 /* TRUE when op is an immediate and an exact power of 2, and given that
3629 OP is 2^scale, scale >= LOW && scale <= HIGH. When OP is a vector,
3630 all entries must be the same. */
3631 bool
3632 exp2_immediate_p (rtx op, enum machine_mode mode, int low, int high)
3633 {
3634 enum machine_mode int_mode;
3635 HOST_WIDE_INT val;
3636 unsigned char arr[16];
3637 int bytes, i, j;
3638
3639 gcc_assert (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
3640 || GET_CODE (op) == CONST_VECTOR);
3641
3642 if (GET_CODE (op) == CONST_VECTOR
3643 && !const_vector_immediate_p (op))
3644 return 0;
3645
3646 if (GET_MODE (op) != VOIDmode)
3647 mode = GET_MODE (op);
3648
3649 constant_to_array (mode, op, arr);
3650
3651 if (VECTOR_MODE_P (mode))
3652 mode = GET_MODE_INNER (mode);
3653
3654 bytes = GET_MODE_SIZE (mode);
3655 int_mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
3656
3657 /* Check that bytes are repeated. */
3658 for (i = bytes; i < 16; i += bytes)
3659 for (j = 0; j < bytes; j++)
3660 if (arr[j] != arr[i + j])
3661 return 0;
3662
3663 val = arr[0];
3664 for (j = 1; j < bytes; j++)
3665 val = (val << 8) | arr[j];
3666
3667 val = trunc_int_for_mode (val, int_mode);
3668
3669 /* Currently, we only handle SFmode */
3670 gcc_assert (mode == SFmode);
3671 if (mode == SFmode)
3672 {
3673 int exp = (val >> 23) - 127;
3674 return val > 0 && (val & 0x007fffff) == 0
3675 && exp >= low && exp <= high;
3676 }
3677 return FALSE;
3678 }
3679
3680 /* Return true if X is a SYMBOL_REF to an __ea qualified variable. */
3681
3682 static int
3683 ea_symbol_ref (rtx *px, void *data ATTRIBUTE_UNUSED)
3684 {
3685 rtx x = *px;
3686 tree decl;
3687
3688 if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS)
3689 {
3690 rtx plus = XEXP (x, 0);
3691 rtx op0 = XEXP (plus, 0);
3692 rtx op1 = XEXP (plus, 1);
3693 if (GET_CODE (op1) == CONST_INT)
3694 x = op0;
3695 }
3696
3697 return (GET_CODE (x) == SYMBOL_REF
3698 && (decl = SYMBOL_REF_DECL (x)) != 0
3699 && TREE_CODE (decl) == VAR_DECL
3700 && TYPE_ADDR_SPACE (TREE_TYPE (decl)));
3701 }
3702
3703 /* We accept:
3704 - any 32-bit constant (SImode, SFmode)
3705 - any constant that can be generated with fsmbi (any mode)
3706 - a 64-bit constant where the high and low bits are identical
3707 (DImode, DFmode)
3708 - a 128-bit constant where the four 32-bit words match. */
3709 int
3710 spu_legitimate_constant_p (rtx x)
3711 {
3712 if (GET_CODE (x) == HIGH)
3713 x = XEXP (x, 0);
3714
3715 /* Reject any __ea qualified reference. These can't appear in
3716 instructions but must be forced to the constant pool. */
3717 if (for_each_rtx (&x, ea_symbol_ref, 0))
3718 return 0;
3719
3720 /* V4SI with all identical symbols is valid. */
3721 if (!flag_pic
3722 && GET_MODE (x) == V4SImode
3723 && (GET_CODE (CONST_VECTOR_ELT (x, 0)) == SYMBOL_REF
3724 || GET_CODE (CONST_VECTOR_ELT (x, 0)) == LABEL_REF
3725 || GET_CODE (CONST_VECTOR_ELT (x, 0)) == CONST))
3726 return CONST_VECTOR_ELT (x, 0) == CONST_VECTOR_ELT (x, 1)
3727 && CONST_VECTOR_ELT (x, 1) == CONST_VECTOR_ELT (x, 2)
3728 && CONST_VECTOR_ELT (x, 2) == CONST_VECTOR_ELT (x, 3);
3729
3730 if (GET_CODE (x) == CONST_VECTOR
3731 && !const_vector_immediate_p (x))
3732 return 0;
3733 return 1;
3734 }
3735
3736 /* Valid address are:
3737 - symbol_ref, label_ref, const
3738 - reg
3739 - reg + const_int, where const_int is 16 byte aligned
3740 - reg + reg, alignment doesn't matter
3741 The alignment matters in the reg+const case because lqd and stqd
3742 ignore the 4 least significant bits of the const. We only care about
3743 16 byte modes because the expand phase will change all smaller MEM
3744 references to TImode. */
3745 static bool
3746 spu_legitimate_address_p (enum machine_mode mode,
3747 rtx x, bool reg_ok_strict)
3748 {
3749 int aligned = GET_MODE_SIZE (mode) >= 16;
3750 if (aligned
3751 && GET_CODE (x) == AND
3752 && GET_CODE (XEXP (x, 1)) == CONST_INT
3753 && INTVAL (XEXP (x, 1)) == (HOST_WIDE_INT) - 16)
3754 x = XEXP (x, 0);
3755 switch (GET_CODE (x))
3756 {
3757 case LABEL_REF:
3758 return !TARGET_LARGE_MEM;
3759
3760 case SYMBOL_REF:
3761 case CONST:
3762 /* Keep __ea references until reload so that spu_expand_mov can see them
3763 in MEMs. */
3764 if (ea_symbol_ref (&x, 0))
3765 return !reload_in_progress && !reload_completed;
3766 return !TARGET_LARGE_MEM;
3767
3768 case CONST_INT:
3769 return INTVAL (x) >= 0 && INTVAL (x) <= 0x3ffff;
3770
3771 case SUBREG:
3772 x = XEXP (x, 0);
3773 if (REG_P (x))
3774 return 0;
3775
3776 case REG:
3777 return INT_REG_OK_FOR_BASE_P (x, reg_ok_strict);
3778
3779 case PLUS:
3780 case LO_SUM:
3781 {
3782 rtx op0 = XEXP (x, 0);
3783 rtx op1 = XEXP (x, 1);
3784 if (GET_CODE (op0) == SUBREG)
3785 op0 = XEXP (op0, 0);
3786 if (GET_CODE (op1) == SUBREG)
3787 op1 = XEXP (op1, 0);
3788 if (GET_CODE (op0) == REG
3789 && INT_REG_OK_FOR_BASE_P (op0, reg_ok_strict)
3790 && GET_CODE (op1) == CONST_INT
3791 && INTVAL (op1) >= -0x2000
3792 && INTVAL (op1) <= 0x1fff
3793 && (!aligned || (INTVAL (op1) & 15) == 0))
3794 return TRUE;
3795 if (GET_CODE (op0) == REG
3796 && INT_REG_OK_FOR_BASE_P (op0, reg_ok_strict)
3797 && GET_CODE (op1) == REG
3798 && INT_REG_OK_FOR_INDEX_P (op1, reg_ok_strict))
3799 return TRUE;
3800 }
3801 break;
3802
3803 default:
3804 break;
3805 }
3806 return FALSE;
3807 }
3808
3809 /* Like spu_legitimate_address_p, except with named addresses. */
3810 static bool
3811 spu_addr_space_legitimate_address_p (enum machine_mode mode, rtx x,
3812 bool reg_ok_strict, addr_space_t as)
3813 {
3814 if (as == ADDR_SPACE_EA)
3815 return (REG_P (x) && (GET_MODE (x) == EAmode));
3816
3817 else if (as != ADDR_SPACE_GENERIC)
3818 gcc_unreachable ();
3819
3820 return spu_legitimate_address_p (mode, x, reg_ok_strict);
3821 }
3822
3823 /* When the address is reg + const_int, force the const_int into a
3824 register. */
3825 rtx
3826 spu_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
3827 enum machine_mode mode ATTRIBUTE_UNUSED)
3828 {
3829 rtx op0, op1;
3830 /* Make sure both operands are registers. */
3831 if (GET_CODE (x) == PLUS)
3832 {
3833 op0 = XEXP (x, 0);
3834 op1 = XEXP (x, 1);
3835 if (ALIGNED_SYMBOL_REF_P (op0))
3836 {
3837 op0 = force_reg (Pmode, op0);
3838 mark_reg_pointer (op0, 128);
3839 }
3840 else if (GET_CODE (op0) != REG)
3841 op0 = force_reg (Pmode, op0);
3842 if (ALIGNED_SYMBOL_REF_P (op1))
3843 {
3844 op1 = force_reg (Pmode, op1);
3845 mark_reg_pointer (op1, 128);
3846 }
3847 else if (GET_CODE (op1) != REG)
3848 op1 = force_reg (Pmode, op1);
3849 x = gen_rtx_PLUS (Pmode, op0, op1);
3850 }
3851 return x;
3852 }
3853
3854 /* Like spu_legitimate_address, except with named address support. */
3855 static rtx
3856 spu_addr_space_legitimize_address (rtx x, rtx oldx, enum machine_mode mode,
3857 addr_space_t as)
3858 {
3859 if (as != ADDR_SPACE_GENERIC)
3860 return x;
3861
3862 return spu_legitimize_address (x, oldx, mode);
3863 }
3864
3865 /* Handle an attribute requiring a FUNCTION_DECL; arguments as in
3866 struct attribute_spec.handler. */
3867 static tree
3868 spu_handle_fndecl_attribute (tree * node,
3869 tree name,
3870 tree args ATTRIBUTE_UNUSED,
3871 int flags ATTRIBUTE_UNUSED, bool * no_add_attrs)
3872 {
3873 if (TREE_CODE (*node) != FUNCTION_DECL)
3874 {
3875 warning (0, "%qE attribute only applies to functions",
3876 name);
3877 *no_add_attrs = true;
3878 }
3879
3880 return NULL_TREE;
3881 }
3882
3883 /* Handle the "vector" attribute. */
3884 static tree
3885 spu_handle_vector_attribute (tree * node, tree name,
3886 tree args ATTRIBUTE_UNUSED,
3887 int flags ATTRIBUTE_UNUSED, bool * no_add_attrs)
3888 {
3889 tree type = *node, result = NULL_TREE;
3890 enum machine_mode mode;
3891 int unsigned_p;
3892
3893 while (POINTER_TYPE_P (type)
3894 || TREE_CODE (type) == FUNCTION_TYPE
3895 || TREE_CODE (type) == METHOD_TYPE || TREE_CODE (type) == ARRAY_TYPE)
3896 type = TREE_TYPE (type);
3897
3898 mode = TYPE_MODE (type);
3899
3900 unsigned_p = TYPE_UNSIGNED (type);
3901 switch (mode)
3902 {
3903 case DImode:
3904 result = (unsigned_p ? unsigned_V2DI_type_node : V2DI_type_node);
3905 break;
3906 case SImode:
3907 result = (unsigned_p ? unsigned_V4SI_type_node : V4SI_type_node);
3908 break;
3909 case HImode:
3910 result = (unsigned_p ? unsigned_V8HI_type_node : V8HI_type_node);
3911 break;
3912 case QImode:
3913 result = (unsigned_p ? unsigned_V16QI_type_node : V16QI_type_node);
3914 break;
3915 case SFmode:
3916 result = V4SF_type_node;
3917 break;
3918 case DFmode:
3919 result = V2DF_type_node;
3920 break;
3921 default:
3922 break;
3923 }
3924
3925 /* Propagate qualifiers attached to the element type
3926 onto the vector type. */
3927 if (result && result != type && TYPE_QUALS (type))
3928 result = build_qualified_type (result, TYPE_QUALS (type));
3929
3930 *no_add_attrs = true; /* No need to hang on to the attribute. */
3931
3932 if (!result)
3933 warning (0, "%qE attribute ignored", name);
3934 else
3935 *node = lang_hooks.types.reconstruct_complex_type (*node, result);
3936
3937 return NULL_TREE;
3938 }
3939
3940 /* Return nonzero if FUNC is a naked function. */
3941 static int
3942 spu_naked_function_p (tree func)
3943 {
3944 tree a;
3945
3946 if (TREE_CODE (func) != FUNCTION_DECL)
3947 abort ();
3948
3949 a = lookup_attribute ("naked", DECL_ATTRIBUTES (func));
3950 return a != NULL_TREE;
3951 }
3952
3953 int
3954 spu_initial_elimination_offset (int from, int to)
3955 {
3956 int saved_regs_size = spu_saved_regs_size ();
3957 int sp_offset = 0;
3958 if (!current_function_is_leaf || crtl->outgoing_args_size
3959 || get_frame_size () || saved_regs_size)
3960 sp_offset = STACK_POINTER_OFFSET;
3961 if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
3962 return get_frame_size () + crtl->outgoing_args_size + sp_offset;
3963 else if (from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
3964 return get_frame_size ();
3965 else if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
3966 return sp_offset + crtl->outgoing_args_size
3967 + get_frame_size () + saved_regs_size + STACK_POINTER_OFFSET;
3968 else if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
3969 return get_frame_size () + saved_regs_size + sp_offset;
3970 else
3971 gcc_unreachable ();
3972 }
3973
3974 rtx
3975 spu_function_value (const_tree type, const_tree func ATTRIBUTE_UNUSED)
3976 {
3977 enum machine_mode mode = TYPE_MODE (type);
3978 int byte_size = ((mode == BLKmode)
3979 ? int_size_in_bytes (type) : GET_MODE_SIZE (mode));
3980
3981 /* Make sure small structs are left justified in a register. */
3982 if ((mode == BLKmode || (type && AGGREGATE_TYPE_P (type)))
3983 && byte_size <= UNITS_PER_WORD * MAX_REGISTER_RETURN && byte_size > 0)
3984 {
3985 enum machine_mode smode;
3986 rtvec v;
3987 int i;
3988 int nregs = (byte_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3989 int n = byte_size / UNITS_PER_WORD;
3990 v = rtvec_alloc (nregs);
3991 for (i = 0; i < n; i++)
3992 {
3993 RTVEC_ELT (v, i) = gen_rtx_EXPR_LIST (VOIDmode,
3994 gen_rtx_REG (TImode,
3995 FIRST_RETURN_REGNUM
3996 + i),
3997 GEN_INT (UNITS_PER_WORD * i));
3998 byte_size -= UNITS_PER_WORD;
3999 }
4000
4001 if (n < nregs)
4002 {
4003 if (byte_size < 4)
4004 byte_size = 4;
4005 smode =
4006 smallest_mode_for_size (byte_size * BITS_PER_UNIT, MODE_INT);
4007 RTVEC_ELT (v, n) =
4008 gen_rtx_EXPR_LIST (VOIDmode,
4009 gen_rtx_REG (smode, FIRST_RETURN_REGNUM + n),
4010 GEN_INT (UNITS_PER_WORD * n));
4011 }
4012 return gen_rtx_PARALLEL (mode, v);
4013 }
4014 return gen_rtx_REG (mode, FIRST_RETURN_REGNUM);
4015 }
4016
4017 static rtx
4018 spu_function_arg (CUMULATIVE_ARGS *cum,
4019 enum machine_mode mode,
4020 const_tree type, bool named ATTRIBUTE_UNUSED)
4021 {
4022 int byte_size;
4023
4024 if (cum >= MAX_REGISTER_ARGS)
4025 return 0;
4026
4027 byte_size = ((mode == BLKmode)
4028 ? int_size_in_bytes (type) : GET_MODE_SIZE (mode));
4029
4030 /* The ABI does not allow parameters to be passed partially in
4031 reg and partially in stack. */
4032 if ((cum + (byte_size + 15) / 16) > MAX_REGISTER_ARGS)
4033 return 0;
4034
4035 /* Make sure small structs are left justified in a register. */
4036 if ((mode == BLKmode || (type && AGGREGATE_TYPE_P (type)))
4037 && byte_size < UNITS_PER_WORD && byte_size > 0)
4038 {
4039 enum machine_mode smode;
4040 rtx gr_reg;
4041 if (byte_size < 4)
4042 byte_size = 4;
4043 smode = smallest_mode_for_size (byte_size * BITS_PER_UNIT, MODE_INT);
4044 gr_reg = gen_rtx_EXPR_LIST (VOIDmode,
4045 gen_rtx_REG (smode, FIRST_ARG_REGNUM + cum),
4046 const0_rtx);
4047 return gen_rtx_PARALLEL (mode, gen_rtvec (1, gr_reg));
4048 }
4049 else
4050 return gen_rtx_REG (mode, FIRST_ARG_REGNUM + cum);
4051 }
4052
4053 static void
4054 spu_function_arg_advance (CUMULATIVE_ARGS * cum, enum machine_mode mode,
4055 const_tree type, bool named ATTRIBUTE_UNUSED)
4056 {
4057 *cum += (type && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
4058 ? 1
4059 : mode == BLKmode
4060 ? ((int_size_in_bytes (type) + 15) / 16)
4061 : mode == VOIDmode
4062 ? 1
4063 : HARD_REGNO_NREGS (cum, mode));
4064 }
4065
4066 /* Variable sized types are passed by reference. */
4067 static bool
4068 spu_pass_by_reference (CUMULATIVE_ARGS * cum ATTRIBUTE_UNUSED,
4069 enum machine_mode mode ATTRIBUTE_UNUSED,
4070 const_tree type, bool named ATTRIBUTE_UNUSED)
4071 {
4072 return type && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST;
4073 }
4074 \f
4075
4076 /* Var args. */
4077
4078 /* Create and return the va_list datatype.
4079
4080 On SPU, va_list is an array type equivalent to
4081
4082 typedef struct __va_list_tag
4083 {
4084 void *__args __attribute__((__aligned(16)));
4085 void *__skip __attribute__((__aligned(16)));
4086
4087 } va_list[1];
4088
4089 where __args points to the arg that will be returned by the next
4090 va_arg(), and __skip points to the previous stack frame such that
4091 when __args == __skip we should advance __args by 32 bytes. */
4092 static tree
4093 spu_build_builtin_va_list (void)
4094 {
4095 tree f_args, f_skip, record, type_decl;
4096 bool owp;
4097
4098 record = (*lang_hooks.types.make_type) (RECORD_TYPE);
4099
4100 type_decl =
4101 build_decl (BUILTINS_LOCATION,
4102 TYPE_DECL, get_identifier ("__va_list_tag"), record);
4103
4104 f_args = build_decl (BUILTINS_LOCATION,
4105 FIELD_DECL, get_identifier ("__args"), ptr_type_node);
4106 f_skip = build_decl (BUILTINS_LOCATION,
4107 FIELD_DECL, get_identifier ("__skip"), ptr_type_node);
4108
4109 DECL_FIELD_CONTEXT (f_args) = record;
4110 DECL_ALIGN (f_args) = 128;
4111 DECL_USER_ALIGN (f_args) = 1;
4112
4113 DECL_FIELD_CONTEXT (f_skip) = record;
4114 DECL_ALIGN (f_skip) = 128;
4115 DECL_USER_ALIGN (f_skip) = 1;
4116
4117 TREE_CHAIN (record) = type_decl;
4118 TYPE_NAME (record) = type_decl;
4119 TYPE_FIELDS (record) = f_args;
4120 DECL_CHAIN (f_args) = f_skip;
4121
4122 /* We know this is being padded and we want it too. It is an internal
4123 type so hide the warnings from the user. */
4124 owp = warn_padded;
4125 warn_padded = false;
4126
4127 layout_type (record);
4128
4129 warn_padded = owp;
4130
4131 /* The correct type is an array type of one element. */
4132 return build_array_type (record, build_index_type (size_zero_node));
4133 }
4134
4135 /* Implement va_start by filling the va_list structure VALIST.
4136 NEXTARG points to the first anonymous stack argument.
4137
4138 The following global variables are used to initialize
4139 the va_list structure:
4140
4141 crtl->args.info;
4142 the CUMULATIVE_ARGS for this function
4143
4144 crtl->args.arg_offset_rtx:
4145 holds the offset of the first anonymous stack argument
4146 (relative to the virtual arg pointer). */
4147
4148 static void
4149 spu_va_start (tree valist, rtx nextarg)
4150 {
4151 tree f_args, f_skip;
4152 tree args, skip, t;
4153
4154 f_args = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
4155 f_skip = DECL_CHAIN (f_args);
4156
4157 valist = build_va_arg_indirect_ref (valist);
4158 args =
4159 build3 (COMPONENT_REF, TREE_TYPE (f_args), valist, f_args, NULL_TREE);
4160 skip =
4161 build3 (COMPONENT_REF, TREE_TYPE (f_skip), valist, f_skip, NULL_TREE);
4162
4163 /* Find the __args area. */
4164 t = make_tree (TREE_TYPE (args), nextarg);
4165 if (crtl->args.pretend_args_size > 0)
4166 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (args), t,
4167 size_int (-STACK_POINTER_OFFSET));
4168 t = build2 (MODIFY_EXPR, TREE_TYPE (args), args, t);
4169 TREE_SIDE_EFFECTS (t) = 1;
4170 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4171
4172 /* Find the __skip area. */
4173 t = make_tree (TREE_TYPE (skip), virtual_incoming_args_rtx);
4174 t = build2 (POINTER_PLUS_EXPR, TREE_TYPE (skip), t,
4175 size_int (crtl->args.pretend_args_size
4176 - STACK_POINTER_OFFSET));
4177 t = build2 (MODIFY_EXPR, TREE_TYPE (skip), skip, t);
4178 TREE_SIDE_EFFECTS (t) = 1;
4179 expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
4180 }
4181
4182 /* Gimplify va_arg by updating the va_list structure
4183 VALIST as required to retrieve an argument of type
4184 TYPE, and returning that argument.
4185
4186 ret = va_arg(VALIST, TYPE);
4187
4188 generates code equivalent to:
4189
4190 paddedsize = (sizeof(TYPE) + 15) & -16;
4191 if (VALIST.__args + paddedsize > VALIST.__skip
4192 && VALIST.__args <= VALIST.__skip)
4193 addr = VALIST.__skip + 32;
4194 else
4195 addr = VALIST.__args;
4196 VALIST.__args = addr + paddedsize;
4197 ret = *(TYPE *)addr;
4198 */
4199 static tree
4200 spu_gimplify_va_arg_expr (tree valist, tree type, gimple_seq * pre_p,
4201 gimple_seq * post_p ATTRIBUTE_UNUSED)
4202 {
4203 tree f_args, f_skip;
4204 tree args, skip;
4205 HOST_WIDE_INT size, rsize;
4206 tree paddedsize, addr, tmp;
4207 bool pass_by_reference_p;
4208
4209 f_args = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
4210 f_skip = DECL_CHAIN (f_args);
4211
4212 valist = build_simple_mem_ref (valist);
4213 args =
4214 build3 (COMPONENT_REF, TREE_TYPE (f_args), valist, f_args, NULL_TREE);
4215 skip =
4216 build3 (COMPONENT_REF, TREE_TYPE (f_skip), valist, f_skip, NULL_TREE);
4217
4218 addr = create_tmp_var (ptr_type_node, "va_arg");
4219
4220 /* if an object is dynamically sized, a pointer to it is passed
4221 instead of the object itself. */
4222 pass_by_reference_p = spu_pass_by_reference (NULL, TYPE_MODE (type), type,
4223 false);
4224 if (pass_by_reference_p)
4225 type = build_pointer_type (type);
4226 size = int_size_in_bytes (type);
4227 rsize = ((size + UNITS_PER_WORD - 1) / UNITS_PER_WORD) * UNITS_PER_WORD;
4228
4229 /* build conditional expression to calculate addr. The expression
4230 will be gimplified later. */
4231 paddedsize = size_int (rsize);
4232 tmp = build2 (POINTER_PLUS_EXPR, ptr_type_node, unshare_expr (args), paddedsize);
4233 tmp = build2 (TRUTH_AND_EXPR, boolean_type_node,
4234 build2 (GT_EXPR, boolean_type_node, tmp, unshare_expr (skip)),
4235 build2 (LE_EXPR, boolean_type_node, unshare_expr (args),
4236 unshare_expr (skip)));
4237
4238 tmp = build3 (COND_EXPR, ptr_type_node, tmp,
4239 build2 (POINTER_PLUS_EXPR, ptr_type_node, unshare_expr (skip),
4240 size_int (32)), unshare_expr (args));
4241
4242 gimplify_assign (addr, tmp, pre_p);
4243
4244 /* update VALIST.__args */
4245 tmp = build2 (POINTER_PLUS_EXPR, ptr_type_node, addr, paddedsize);
4246 gimplify_assign (unshare_expr (args), tmp, pre_p);
4247
4248 addr = fold_convert (build_pointer_type_for_mode (type, ptr_mode, true),
4249 addr);
4250
4251 if (pass_by_reference_p)
4252 addr = build_va_arg_indirect_ref (addr);
4253
4254 return build_va_arg_indirect_ref (addr);
4255 }
4256
4257 /* Save parameter registers starting with the register that corresponds
4258 to the first unnamed parameters. If the first unnamed parameter is
4259 in the stack then save no registers. Set pretend_args_size to the
4260 amount of space needed to save the registers. */
4261 void
4262 spu_setup_incoming_varargs (CUMULATIVE_ARGS * cum, enum machine_mode mode,
4263 tree type, int *pretend_size, int no_rtl)
4264 {
4265 if (!no_rtl)
4266 {
4267 rtx tmp;
4268 int regno;
4269 int offset;
4270 int ncum = *cum;
4271
4272 /* cum currently points to the last named argument, we want to
4273 start at the next argument. */
4274 spu_function_arg_advance (&ncum, mode, type, true);
4275
4276 offset = -STACK_POINTER_OFFSET;
4277 for (regno = ncum; regno < MAX_REGISTER_ARGS; regno++)
4278 {
4279 tmp = gen_frame_mem (V4SImode,
4280 plus_constant (virtual_incoming_args_rtx,
4281 offset));
4282 emit_move_insn (tmp,
4283 gen_rtx_REG (V4SImode, FIRST_ARG_REGNUM + regno));
4284 offset += 16;
4285 }
4286 *pretend_size = offset + STACK_POINTER_OFFSET;
4287 }
4288 }
4289 \f
4290 void
4291 spu_conditional_register_usage (void)
4292 {
4293 if (flag_pic)
4294 {
4295 fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
4296 call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
4297 }
4298 }
4299
4300 /* This is called any time we inspect the alignment of a register for
4301 addresses. */
4302 static int
4303 reg_aligned_for_addr (rtx x)
4304 {
4305 int regno =
4306 REGNO (x) < FIRST_PSEUDO_REGISTER ? ORIGINAL_REGNO (x) : REGNO (x);
4307 return REGNO_POINTER_ALIGN (regno) >= 128;
4308 }
4309
4310 /* Encode symbol attributes (local vs. global, tls model) of a SYMBOL_REF
4311 into its SYMBOL_REF_FLAGS. */
4312 static void
4313 spu_encode_section_info (tree decl, rtx rtl, int first)
4314 {
4315 default_encode_section_info (decl, rtl, first);
4316
4317 /* If a variable has a forced alignment to < 16 bytes, mark it with
4318 SYMBOL_FLAG_ALIGN1. */
4319 if (TREE_CODE (decl) == VAR_DECL
4320 && DECL_USER_ALIGN (decl) && DECL_ALIGN (decl) < 128)
4321 SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_ALIGN1;
4322 }
4323
4324 /* Return TRUE if we are certain the mem refers to a complete object
4325 which is both 16-byte aligned and padded to a 16-byte boundary. This
4326 would make it safe to store with a single instruction.
4327 We guarantee the alignment and padding for static objects by aligning
4328 all of them to 16-bytes. (DATA_ALIGNMENT and CONSTANT_ALIGNMENT.)
4329 FIXME: We currently cannot guarantee this for objects on the stack
4330 because assign_parm_setup_stack calls assign_stack_local with the
4331 alignment of the parameter mode and in that case the alignment never
4332 gets adjusted by LOCAL_ALIGNMENT. */
4333 static int
4334 store_with_one_insn_p (rtx mem)
4335 {
4336 enum machine_mode mode = GET_MODE (mem);
4337 rtx addr = XEXP (mem, 0);
4338 if (mode == BLKmode)
4339 return 0;
4340 if (GET_MODE_SIZE (mode) >= 16)
4341 return 1;
4342 /* Only static objects. */
4343 if (GET_CODE (addr) == SYMBOL_REF)
4344 {
4345 /* We use the associated declaration to make sure the access is
4346 referring to the whole object.
4347 We check both MEM_EXPR and and SYMBOL_REF_DECL. I'm not sure
4348 if it is necessary. Will there be cases where one exists, and
4349 the other does not? Will there be cases where both exist, but
4350 have different types? */
4351 tree decl = MEM_EXPR (mem);
4352 if (decl
4353 && TREE_CODE (decl) == VAR_DECL
4354 && GET_MODE (mem) == TYPE_MODE (TREE_TYPE (decl)))
4355 return 1;
4356 decl = SYMBOL_REF_DECL (addr);
4357 if (decl
4358 && TREE_CODE (decl) == VAR_DECL
4359 && GET_MODE (mem) == TYPE_MODE (TREE_TYPE (decl)))
4360 return 1;
4361 }
4362 return 0;
4363 }
4364
4365 /* Return 1 when the address is not valid for a simple load and store as
4366 required by the '_mov*' patterns. We could make this less strict
4367 for loads, but we prefer mem's to look the same so they are more
4368 likely to be merged. */
4369 static int
4370 address_needs_split (rtx mem)
4371 {
4372 if (GET_MODE_SIZE (GET_MODE (mem)) < 16
4373 && (GET_MODE_SIZE (GET_MODE (mem)) < 4
4374 || !(store_with_one_insn_p (mem)
4375 || mem_is_padded_component_ref (mem))))
4376 return 1;
4377
4378 return 0;
4379 }
4380
4381 static GTY(()) rtx cache_fetch; /* __cache_fetch function */
4382 static GTY(()) rtx cache_fetch_dirty; /* __cache_fetch_dirty function */
4383 static alias_set_type ea_alias_set = -1; /* alias set for __ea memory */
4384
4385 /* MEM is known to be an __ea qualified memory access. Emit a call to
4386 fetch the ppu memory to local store, and return its address in local
4387 store. */
4388
4389 static void
4390 ea_load_store (rtx mem, bool is_store, rtx ea_addr, rtx data_addr)
4391 {
4392 if (is_store)
4393 {
4394 rtx ndirty = GEN_INT (GET_MODE_SIZE (GET_MODE (mem)));
4395 if (!cache_fetch_dirty)
4396 cache_fetch_dirty = init_one_libfunc ("__cache_fetch_dirty");
4397 emit_library_call_value (cache_fetch_dirty, data_addr, LCT_NORMAL, Pmode,
4398 2, ea_addr, EAmode, ndirty, SImode);
4399 }
4400 else
4401 {
4402 if (!cache_fetch)
4403 cache_fetch = init_one_libfunc ("__cache_fetch");
4404 emit_library_call_value (cache_fetch, data_addr, LCT_NORMAL, Pmode,
4405 1, ea_addr, EAmode);
4406 }
4407 }
4408
4409 /* Like ea_load_store, but do the cache tag comparison and, for stores,
4410 dirty bit marking, inline.
4411
4412 The cache control data structure is an array of
4413
4414 struct __cache_tag_array
4415 {
4416 unsigned int tag_lo[4];
4417 unsigned int tag_hi[4];
4418 void *data_pointer[4];
4419 int reserved[4];
4420 vector unsigned short dirty_bits[4];
4421 } */
4422
4423 static void
4424 ea_load_store_inline (rtx mem, bool is_store, rtx ea_addr, rtx data_addr)
4425 {
4426 rtx ea_addr_si;
4427 HOST_WIDE_INT v;
4428 rtx tag_size_sym = gen_rtx_SYMBOL_REF (Pmode, "__cache_tag_array_size");
4429 rtx tag_arr_sym = gen_rtx_SYMBOL_REF (Pmode, "__cache_tag_array");
4430 rtx index_mask = gen_reg_rtx (SImode);
4431 rtx tag_arr = gen_reg_rtx (Pmode);
4432 rtx splat_mask = gen_reg_rtx (TImode);
4433 rtx splat = gen_reg_rtx (V4SImode);
4434 rtx splat_hi = NULL_RTX;
4435 rtx tag_index = gen_reg_rtx (Pmode);
4436 rtx block_off = gen_reg_rtx (SImode);
4437 rtx tag_addr = gen_reg_rtx (Pmode);
4438 rtx tag = gen_reg_rtx (V4SImode);
4439 rtx cache_tag = gen_reg_rtx (V4SImode);
4440 rtx cache_tag_hi = NULL_RTX;
4441 rtx cache_ptrs = gen_reg_rtx (TImode);
4442 rtx cache_ptrs_si = gen_reg_rtx (SImode);
4443 rtx tag_equal = gen_reg_rtx (V4SImode);
4444 rtx tag_equal_hi = NULL_RTX;
4445 rtx tag_eq_pack = gen_reg_rtx (V4SImode);
4446 rtx tag_eq_pack_si = gen_reg_rtx (SImode);
4447 rtx eq_index = gen_reg_rtx (SImode);
4448 rtx bcomp, hit_label, hit_ref, cont_label, insn;
4449
4450 if (spu_ea_model != 32)
4451 {
4452 splat_hi = gen_reg_rtx (V4SImode);
4453 cache_tag_hi = gen_reg_rtx (V4SImode);
4454 tag_equal_hi = gen_reg_rtx (V4SImode);
4455 }
4456
4457 emit_move_insn (index_mask, plus_constant (tag_size_sym, -128));
4458 emit_move_insn (tag_arr, tag_arr_sym);
4459 v = 0x0001020300010203LL;
4460 emit_move_insn (splat_mask, immed_double_const (v, v, TImode));
4461 ea_addr_si = ea_addr;
4462 if (spu_ea_model != 32)
4463 ea_addr_si = convert_to_mode (SImode, ea_addr, 1);
4464
4465 /* tag_index = ea_addr & (tag_array_size - 128) */
4466 emit_insn (gen_andsi3 (tag_index, ea_addr_si, index_mask));
4467
4468 /* splat ea_addr to all 4 slots. */
4469 emit_insn (gen_shufb (splat, ea_addr_si, ea_addr_si, splat_mask));
4470 /* Similarly for high 32 bits of ea_addr. */
4471 if (spu_ea_model != 32)
4472 emit_insn (gen_shufb (splat_hi, ea_addr, ea_addr, splat_mask));
4473
4474 /* block_off = ea_addr & 127 */
4475 emit_insn (gen_andsi3 (block_off, ea_addr_si, spu_const (SImode, 127)));
4476
4477 /* tag_addr = tag_arr + tag_index */
4478 emit_insn (gen_addsi3 (tag_addr, tag_arr, tag_index));
4479
4480 /* Read cache tags. */
4481 emit_move_insn (cache_tag, gen_rtx_MEM (V4SImode, tag_addr));
4482 if (spu_ea_model != 32)
4483 emit_move_insn (cache_tag_hi, gen_rtx_MEM (V4SImode,
4484 plus_constant (tag_addr, 16)));
4485
4486 /* tag = ea_addr & -128 */
4487 emit_insn (gen_andv4si3 (tag, splat, spu_const (V4SImode, -128)));
4488
4489 /* Read all four cache data pointers. */
4490 emit_move_insn (cache_ptrs, gen_rtx_MEM (TImode,
4491 plus_constant (tag_addr, 32)));
4492
4493 /* Compare tags. */
4494 emit_insn (gen_ceq_v4si (tag_equal, tag, cache_tag));
4495 if (spu_ea_model != 32)
4496 {
4497 emit_insn (gen_ceq_v4si (tag_equal_hi, splat_hi, cache_tag_hi));
4498 emit_insn (gen_andv4si3 (tag_equal, tag_equal, tag_equal_hi));
4499 }
4500
4501 /* At most one of the tags compare equal, so tag_equal has one
4502 32-bit slot set to all 1's, with the other slots all zero.
4503 gbb picks off low bit from each byte in the 128-bit registers,
4504 so tag_eq_pack is one of 0xf000, 0x0f00, 0x00f0, 0x000f, assuming
4505 we have a hit. */
4506 emit_insn (gen_spu_gbb (tag_eq_pack, spu_gen_subreg (V16QImode, tag_equal)));
4507 emit_insn (gen_spu_convert (tag_eq_pack_si, tag_eq_pack));
4508
4509 /* So counting leading zeros will set eq_index to 16, 20, 24 or 28. */
4510 emit_insn (gen_clzsi2 (eq_index, tag_eq_pack_si));
4511
4512 /* Allowing us to rotate the corresponding cache data pointer to slot0.
4513 (rotating eq_index mod 16 bytes). */
4514 emit_insn (gen_rotqby_ti (cache_ptrs, cache_ptrs, eq_index));
4515 emit_insn (gen_spu_convert (cache_ptrs_si, cache_ptrs));
4516
4517 /* Add block offset to form final data address. */
4518 emit_insn (gen_addsi3 (data_addr, cache_ptrs_si, block_off));
4519
4520 /* Check that we did hit. */
4521 hit_label = gen_label_rtx ();
4522 hit_ref = gen_rtx_LABEL_REF (VOIDmode, hit_label);
4523 bcomp = gen_rtx_NE (SImode, tag_eq_pack_si, const0_rtx);
4524 insn = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
4525 gen_rtx_IF_THEN_ELSE (VOIDmode, bcomp,
4526 hit_ref, pc_rtx)));
4527 /* Say that this branch is very likely to happen. */
4528 v = REG_BR_PROB_BASE - REG_BR_PROB_BASE / 100 - 1;
4529 add_reg_note (insn, REG_BR_PROB, GEN_INT (v));
4530
4531 ea_load_store (mem, is_store, ea_addr, data_addr);
4532 cont_label = gen_label_rtx ();
4533 emit_jump_insn (gen_jump (cont_label));
4534 emit_barrier ();
4535
4536 emit_label (hit_label);
4537
4538 if (is_store)
4539 {
4540 HOST_WIDE_INT v_hi;
4541 rtx dirty_bits = gen_reg_rtx (TImode);
4542 rtx dirty_off = gen_reg_rtx (SImode);
4543 rtx dirty_128 = gen_reg_rtx (TImode);
4544 rtx neg_block_off = gen_reg_rtx (SImode);
4545
4546 /* Set up mask with one dirty bit per byte of the mem we are
4547 writing, starting from top bit. */
4548 v_hi = v = -1;
4549 v <<= (128 - GET_MODE_SIZE (GET_MODE (mem))) & 63;
4550 if ((128 - GET_MODE_SIZE (GET_MODE (mem))) >= 64)
4551 {
4552 v_hi = v;
4553 v = 0;
4554 }
4555 emit_move_insn (dirty_bits, immed_double_const (v, v_hi, TImode));
4556
4557 /* Form index into cache dirty_bits. eq_index is one of
4558 0x10, 0x14, 0x18 or 0x1c. Multiplying by 4 gives us
4559 0x40, 0x50, 0x60 or 0x70 which just happens to be the
4560 offset to each of the four dirty_bits elements. */
4561 emit_insn (gen_ashlsi3 (dirty_off, eq_index, spu_const (SImode, 2)));
4562
4563 emit_insn (gen_spu_lqx (dirty_128, tag_addr, dirty_off));
4564
4565 /* Rotate bit mask to proper bit. */
4566 emit_insn (gen_negsi2 (neg_block_off, block_off));
4567 emit_insn (gen_rotqbybi_ti (dirty_bits, dirty_bits, neg_block_off));
4568 emit_insn (gen_rotqbi_ti (dirty_bits, dirty_bits, neg_block_off));
4569
4570 /* Or in the new dirty bits. */
4571 emit_insn (gen_iorti3 (dirty_128, dirty_bits, dirty_128));
4572
4573 /* Store. */
4574 emit_insn (gen_spu_stqx (dirty_128, tag_addr, dirty_off));
4575 }
4576
4577 emit_label (cont_label);
4578 }
4579
4580 static rtx
4581 expand_ea_mem (rtx mem, bool is_store)
4582 {
4583 rtx ea_addr;
4584 rtx data_addr = gen_reg_rtx (Pmode);
4585 rtx new_mem;
4586
4587 ea_addr = force_reg (EAmode, XEXP (mem, 0));
4588 if (optimize_size || optimize == 0)
4589 ea_load_store (mem, is_store, ea_addr, data_addr);
4590 else
4591 ea_load_store_inline (mem, is_store, ea_addr, data_addr);
4592
4593 if (ea_alias_set == -1)
4594 ea_alias_set = new_alias_set ();
4595
4596 /* We generate a new MEM RTX to refer to the copy of the data
4597 in the cache. We do not copy memory attributes (except the
4598 alignment) from the original MEM, as they may no longer apply
4599 to the cache copy. */
4600 new_mem = gen_rtx_MEM (GET_MODE (mem), data_addr);
4601 set_mem_alias_set (new_mem, ea_alias_set);
4602 set_mem_align (new_mem, MIN (MEM_ALIGN (mem), 128 * 8));
4603
4604 return new_mem;
4605 }
4606
4607 int
4608 spu_expand_mov (rtx * ops, enum machine_mode mode)
4609 {
4610 if (GET_CODE (ops[0]) == SUBREG && !valid_subreg (ops[0]))
4611 abort ();
4612
4613 if (GET_CODE (ops[1]) == SUBREG && !valid_subreg (ops[1]))
4614 {
4615 rtx from = SUBREG_REG (ops[1]);
4616 enum machine_mode imode = int_mode_for_mode (GET_MODE (from));
4617
4618 gcc_assert (GET_MODE_CLASS (mode) == MODE_INT
4619 && GET_MODE_CLASS (imode) == MODE_INT
4620 && subreg_lowpart_p (ops[1]));
4621
4622 if (GET_MODE_SIZE (imode) < 4)
4623 imode = SImode;
4624 if (imode != GET_MODE (from))
4625 from = gen_rtx_SUBREG (imode, from, 0);
4626
4627 if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (imode))
4628 {
4629 enum insn_code icode = convert_optab_handler (trunc_optab,
4630 mode, imode);
4631 emit_insn (GEN_FCN (icode) (ops[0], from));
4632 }
4633 else
4634 emit_insn (gen_extend_insn (ops[0], from, mode, imode, 1));
4635 return 1;
4636 }
4637
4638 /* At least one of the operands needs to be a register. */
4639 if ((reload_in_progress | reload_completed) == 0
4640 && !register_operand (ops[0], mode) && !register_operand (ops[1], mode))
4641 {
4642 rtx temp = force_reg (mode, ops[1]);
4643 emit_move_insn (ops[0], temp);
4644 return 1;
4645 }
4646 if (reload_in_progress || reload_completed)
4647 {
4648 if (CONSTANT_P (ops[1]))
4649 return spu_split_immediate (ops);
4650 return 0;
4651 }
4652
4653 /* Catch the SImode immediates greater than 0x7fffffff, and sign
4654 extend them. */
4655 if (GET_CODE (ops[1]) == CONST_INT)
4656 {
4657 HOST_WIDE_INT val = trunc_int_for_mode (INTVAL (ops[1]), mode);
4658 if (val != INTVAL (ops[1]))
4659 {
4660 emit_move_insn (ops[0], GEN_INT (val));
4661 return 1;
4662 }
4663 }
4664 if (MEM_P (ops[0]))
4665 {
4666 if (MEM_ADDR_SPACE (ops[0]))
4667 ops[0] = expand_ea_mem (ops[0], true);
4668 return spu_split_store (ops);
4669 }
4670 if (MEM_P (ops[1]))
4671 {
4672 if (MEM_ADDR_SPACE (ops[1]))
4673 ops[1] = expand_ea_mem (ops[1], false);
4674 return spu_split_load (ops);
4675 }
4676
4677 return 0;
4678 }
4679
4680 static void
4681 spu_convert_move (rtx dst, rtx src)
4682 {
4683 enum machine_mode mode = GET_MODE (dst);
4684 enum machine_mode int_mode = mode_for_size (GET_MODE_BITSIZE (mode), MODE_INT, 0);
4685 rtx reg;
4686 gcc_assert (GET_MODE (src) == TImode);
4687 reg = int_mode != mode ? gen_reg_rtx (int_mode) : dst;
4688 emit_insn (gen_rtx_SET (VOIDmode, reg,
4689 gen_rtx_TRUNCATE (int_mode,
4690 gen_rtx_LSHIFTRT (TImode, src,
4691 GEN_INT (int_mode == DImode ? 64 : 96)))));
4692 if (int_mode != mode)
4693 {
4694 reg = simplify_gen_subreg (mode, reg, int_mode, 0);
4695 emit_move_insn (dst, reg);
4696 }
4697 }
4698
4699 /* Load TImode values into DST0 and DST1 (when it is non-NULL) using
4700 the address from SRC and SRC+16. Return a REG or CONST_INT that
4701 specifies how many bytes to rotate the loaded registers, plus any
4702 extra from EXTRA_ROTQBY. The address and rotate amounts are
4703 normalized to improve merging of loads and rotate computations. */
4704 static rtx
4705 spu_expand_load (rtx dst0, rtx dst1, rtx src, int extra_rotby)
4706 {
4707 rtx addr = XEXP (src, 0);
4708 rtx p0, p1, rot, addr0, addr1;
4709 int rot_amt;
4710
4711 rot = 0;
4712 rot_amt = 0;
4713
4714 if (MEM_ALIGN (src) >= 128)
4715 /* Address is already aligned; simply perform a TImode load. */ ;
4716 else if (GET_CODE (addr) == PLUS)
4717 {
4718 /* 8 cases:
4719 aligned reg + aligned reg => lqx
4720 aligned reg + unaligned reg => lqx, rotqby
4721 aligned reg + aligned const => lqd
4722 aligned reg + unaligned const => lqd, rotqbyi
4723 unaligned reg + aligned reg => lqx, rotqby
4724 unaligned reg + unaligned reg => lqx, a, rotqby (1 scratch)
4725 unaligned reg + aligned const => lqd, rotqby
4726 unaligned reg + unaligned const -> not allowed by legitimate address
4727 */
4728 p0 = XEXP (addr, 0);
4729 p1 = XEXP (addr, 1);
4730 if (!reg_aligned_for_addr (p0))
4731 {
4732 if (REG_P (p1) && !reg_aligned_for_addr (p1))
4733 {
4734 rot = gen_reg_rtx (SImode);
4735 emit_insn (gen_addsi3 (rot, p0, p1));
4736 }
4737 else if (GET_CODE (p1) == CONST_INT && (INTVAL (p1) & 15))
4738 {
4739 if (INTVAL (p1) > 0
4740 && REG_POINTER (p0)
4741 && INTVAL (p1) * BITS_PER_UNIT
4742 < REGNO_POINTER_ALIGN (REGNO (p0)))
4743 {
4744 rot = gen_reg_rtx (SImode);
4745 emit_insn (gen_addsi3 (rot, p0, p1));
4746 addr = p0;
4747 }
4748 else
4749 {
4750 rtx x = gen_reg_rtx (SImode);
4751 emit_move_insn (x, p1);
4752 if (!spu_arith_operand (p1, SImode))
4753 p1 = x;
4754 rot = gen_reg_rtx (SImode);
4755 emit_insn (gen_addsi3 (rot, p0, p1));
4756 addr = gen_rtx_PLUS (Pmode, p0, x);
4757 }
4758 }
4759 else
4760 rot = p0;
4761 }
4762 else
4763 {
4764 if (GET_CODE (p1) == CONST_INT && (INTVAL (p1) & 15))
4765 {
4766 rot_amt = INTVAL (p1) & 15;
4767 if (INTVAL (p1) & -16)
4768 {
4769 p1 = GEN_INT (INTVAL (p1) & -16);
4770 addr = gen_rtx_PLUS (SImode, p0, p1);
4771 }
4772 else
4773 addr = p0;
4774 }
4775 else if (REG_P (p1) && !reg_aligned_for_addr (p1))
4776 rot = p1;
4777 }
4778 }
4779 else if (REG_P (addr))
4780 {
4781 if (!reg_aligned_for_addr (addr))
4782 rot = addr;
4783 }
4784 else if (GET_CODE (addr) == CONST)
4785 {
4786 if (GET_CODE (XEXP (addr, 0)) == PLUS
4787 && ALIGNED_SYMBOL_REF_P (XEXP (XEXP (addr, 0), 0))
4788 && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
4789 {
4790 rot_amt = INTVAL (XEXP (XEXP (addr, 0), 1));
4791 if (rot_amt & -16)
4792 addr = gen_rtx_CONST (Pmode,
4793 gen_rtx_PLUS (Pmode,
4794 XEXP (XEXP (addr, 0), 0),
4795 GEN_INT (rot_amt & -16)));
4796 else
4797 addr = XEXP (XEXP (addr, 0), 0);
4798 }
4799 else
4800 {
4801 rot = gen_reg_rtx (Pmode);
4802 emit_move_insn (rot, addr);
4803 }
4804 }
4805 else if (GET_CODE (addr) == CONST_INT)
4806 {
4807 rot_amt = INTVAL (addr);
4808 addr = GEN_INT (rot_amt & -16);
4809 }
4810 else if (!ALIGNED_SYMBOL_REF_P (addr))
4811 {
4812 rot = gen_reg_rtx (Pmode);
4813 emit_move_insn (rot, addr);
4814 }
4815
4816 rot_amt += extra_rotby;
4817
4818 rot_amt &= 15;
4819
4820 if (rot && rot_amt)
4821 {
4822 rtx x = gen_reg_rtx (SImode);
4823 emit_insn (gen_addsi3 (x, rot, GEN_INT (rot_amt)));
4824 rot = x;
4825 rot_amt = 0;
4826 }
4827 if (!rot && rot_amt)
4828 rot = GEN_INT (rot_amt);
4829
4830 addr0 = copy_rtx (addr);
4831 addr0 = gen_rtx_AND (SImode, copy_rtx (addr), GEN_INT (-16));
4832 emit_insn (gen__movti (dst0, change_address (src, TImode, addr0)));
4833
4834 if (dst1)
4835 {
4836 addr1 = plus_constant (copy_rtx (addr), 16);
4837 addr1 = gen_rtx_AND (SImode, addr1, GEN_INT (-16));
4838 emit_insn (gen__movti (dst1, change_address (src, TImode, addr1)));
4839 }
4840
4841 return rot;
4842 }
4843
4844 int
4845 spu_split_load (rtx * ops)
4846 {
4847 enum machine_mode mode = GET_MODE (ops[0]);
4848 rtx addr, load, rot;
4849 int rot_amt;
4850
4851 if (GET_MODE_SIZE (mode) >= 16)
4852 return 0;
4853
4854 addr = XEXP (ops[1], 0);
4855 gcc_assert (GET_CODE (addr) != AND);
4856
4857 if (!address_needs_split (ops[1]))
4858 {
4859 ops[1] = change_address (ops[1], TImode, addr);
4860 load = gen_reg_rtx (TImode);
4861 emit_insn (gen__movti (load, ops[1]));
4862 spu_convert_move (ops[0], load);
4863 return 1;
4864 }
4865
4866 rot_amt = GET_MODE_SIZE (mode) < 4 ? GET_MODE_SIZE (mode) - 4 : 0;
4867
4868 load = gen_reg_rtx (TImode);
4869 rot = spu_expand_load (load, 0, ops[1], rot_amt);
4870
4871 if (rot)
4872 emit_insn (gen_rotqby_ti (load, load, rot));
4873
4874 spu_convert_move (ops[0], load);
4875 return 1;
4876 }
4877
4878 int
4879 spu_split_store (rtx * ops)
4880 {
4881 enum machine_mode mode = GET_MODE (ops[0]);
4882 rtx reg;
4883 rtx addr, p0, p1, p1_lo, smem;
4884 int aform;
4885 int scalar;
4886
4887 if (GET_MODE_SIZE (mode) >= 16)
4888 return 0;
4889
4890 addr = XEXP (ops[0], 0);
4891 gcc_assert (GET_CODE (addr) != AND);
4892
4893 if (!address_needs_split (ops[0]))
4894 {
4895 reg = gen_reg_rtx (TImode);
4896 emit_insn (gen_spu_convert (reg, ops[1]));
4897 ops[0] = change_address (ops[0], TImode, addr);
4898 emit_move_insn (ops[0], reg);
4899 return 1;
4900 }
4901
4902 if (GET_CODE (addr) == PLUS)
4903 {
4904 /* 8 cases:
4905 aligned reg + aligned reg => lqx, c?x, shuf, stqx
4906 aligned reg + unaligned reg => lqx, c?x, shuf, stqx
4907 aligned reg + aligned const => lqd, c?d, shuf, stqx
4908 aligned reg + unaligned const => lqd, c?d, shuf, stqx
4909 unaligned reg + aligned reg => lqx, c?x, shuf, stqx
4910 unaligned reg + unaligned reg => lqx, c?x, shuf, stqx
4911 unaligned reg + aligned const => lqd, c?d, shuf, stqx
4912 unaligned reg + unaligned const -> lqx, c?d, shuf, stqx
4913 */
4914 aform = 0;
4915 p0 = XEXP (addr, 0);
4916 p1 = p1_lo = XEXP (addr, 1);
4917 if (REG_P (p0) && GET_CODE (p1) == CONST_INT)
4918 {
4919 p1_lo = GEN_INT (INTVAL (p1) & 15);
4920 if (reg_aligned_for_addr (p0))
4921 {
4922 p1 = GEN_INT (INTVAL (p1) & -16);
4923 if (p1 == const0_rtx)
4924 addr = p0;
4925 else
4926 addr = gen_rtx_PLUS (SImode, p0, p1);
4927 }
4928 else
4929 {
4930 rtx x = gen_reg_rtx (SImode);
4931 emit_move_insn (x, p1);
4932 addr = gen_rtx_PLUS (SImode, p0, x);
4933 }
4934 }
4935 }
4936 else if (REG_P (addr))
4937 {
4938 aform = 0;
4939 p0 = addr;
4940 p1 = p1_lo = const0_rtx;
4941 }
4942 else
4943 {
4944 aform = 1;
4945 p0 = gen_rtx_REG (SImode, STACK_POINTER_REGNUM);
4946 p1 = 0; /* aform doesn't use p1 */
4947 p1_lo = addr;
4948 if (ALIGNED_SYMBOL_REF_P (addr))
4949 p1_lo = const0_rtx;
4950 else if (GET_CODE (addr) == CONST
4951 && GET_CODE (XEXP (addr, 0)) == PLUS
4952 && ALIGNED_SYMBOL_REF_P (XEXP (XEXP (addr, 0), 0))
4953 && GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
4954 {
4955 HOST_WIDE_INT v = INTVAL (XEXP (XEXP (addr, 0), 1));
4956 if ((v & -16) != 0)
4957 addr = gen_rtx_CONST (Pmode,
4958 gen_rtx_PLUS (Pmode,
4959 XEXP (XEXP (addr, 0), 0),
4960 GEN_INT (v & -16)));
4961 else
4962 addr = XEXP (XEXP (addr, 0), 0);
4963 p1_lo = GEN_INT (v & 15);
4964 }
4965 else if (GET_CODE (addr) == CONST_INT)
4966 {
4967 p1_lo = GEN_INT (INTVAL (addr) & 15);
4968 addr = GEN_INT (INTVAL (addr) & -16);
4969 }
4970 else
4971 {
4972 p1_lo = gen_reg_rtx (SImode);
4973 emit_move_insn (p1_lo, addr);
4974 }
4975 }
4976
4977 reg = gen_reg_rtx (TImode);
4978
4979 scalar = store_with_one_insn_p (ops[0]);
4980 if (!scalar)
4981 {
4982 /* We could copy the flags from the ops[0] MEM to mem here,
4983 We don't because we want this load to be optimized away if
4984 possible, and copying the flags will prevent that in certain
4985 cases, e.g. consider the volatile flag. */
4986
4987 rtx pat = gen_reg_rtx (TImode);
4988 rtx lmem = change_address (ops[0], TImode, copy_rtx (addr));
4989 set_mem_alias_set (lmem, 0);
4990 emit_insn (gen_movti (reg, lmem));
4991
4992 if (!p0 || reg_aligned_for_addr (p0))
4993 p0 = stack_pointer_rtx;
4994 if (!p1_lo)
4995 p1_lo = const0_rtx;
4996
4997 emit_insn (gen_cpat (pat, p0, p1_lo, GEN_INT (GET_MODE_SIZE (mode))));
4998 emit_insn (gen_shufb (reg, ops[1], reg, pat));
4999 }
5000 else
5001 {
5002 if (GET_CODE (ops[1]) == REG)
5003 emit_insn (gen_spu_convert (reg, ops[1]));
5004 else if (GET_CODE (ops[1]) == SUBREG)
5005 emit_insn (gen_spu_convert (reg, SUBREG_REG (ops[1])));
5006 else
5007 abort ();
5008 }
5009
5010 if (GET_MODE_SIZE (mode) < 4 && scalar)
5011 emit_insn (gen_ashlti3
5012 (reg, reg, GEN_INT (32 - GET_MODE_BITSIZE (mode))));
5013
5014 smem = change_address (ops[0], TImode, copy_rtx (addr));
5015 /* We can't use the previous alias set because the memory has changed
5016 size and can potentially overlap objects of other types. */
5017 set_mem_alias_set (smem, 0);
5018
5019 emit_insn (gen_movti (smem, reg));
5020 return 1;
5021 }
5022
5023 /* Return TRUE if X is MEM which is a struct member reference
5024 and the member can safely be loaded and stored with a single
5025 instruction because it is padded. */
5026 static int
5027 mem_is_padded_component_ref (rtx x)
5028 {
5029 tree t = MEM_EXPR (x);
5030 tree r;
5031 if (!t || TREE_CODE (t) != COMPONENT_REF)
5032 return 0;
5033 t = TREE_OPERAND (t, 1);
5034 if (!t || TREE_CODE (t) != FIELD_DECL
5035 || DECL_ALIGN (t) < 128 || AGGREGATE_TYPE_P (TREE_TYPE (t)))
5036 return 0;
5037 /* Only do this for RECORD_TYPEs, not UNION_TYPEs. */
5038 r = DECL_FIELD_CONTEXT (t);
5039 if (!r || TREE_CODE (r) != RECORD_TYPE)
5040 return 0;
5041 /* Make sure they are the same mode */
5042 if (GET_MODE (x) != TYPE_MODE (TREE_TYPE (t)))
5043 return 0;
5044 /* If there are no following fields then the field alignment assures
5045 the structure is padded to the alignment which means this field is
5046 padded too. */
5047 if (TREE_CHAIN (t) == 0)
5048 return 1;
5049 /* If the following field is also aligned then this field will be
5050 padded. */
5051 t = TREE_CHAIN (t);
5052 if (TREE_CODE (t) == FIELD_DECL && DECL_ALIGN (t) >= 128)
5053 return 1;
5054 return 0;
5055 }
5056
5057 /* Parse the -mfixed-range= option string. */
5058 static void
5059 fix_range (const char *const_str)
5060 {
5061 int i, first, last;
5062 char *str, *dash, *comma;
5063
5064 /* str must be of the form REG1'-'REG2{,REG1'-'REG} where REG1 and
5065 REG2 are either register names or register numbers. The effect
5066 of this option is to mark the registers in the range from REG1 to
5067 REG2 as ``fixed'' so they won't be used by the compiler. */
5068
5069 i = strlen (const_str);
5070 str = (char *) alloca (i + 1);
5071 memcpy (str, const_str, i + 1);
5072
5073 while (1)
5074 {
5075 dash = strchr (str, '-');
5076 if (!dash)
5077 {
5078 warning (0, "value of -mfixed-range must have form REG1-REG2");
5079 return;
5080 }
5081 *dash = '\0';
5082 comma = strchr (dash + 1, ',');
5083 if (comma)
5084 *comma = '\0';
5085
5086 first = decode_reg_name (str);
5087 if (first < 0)
5088 {
5089 warning (0, "unknown register name: %s", str);
5090 return;
5091 }
5092
5093 last = decode_reg_name (dash + 1);
5094 if (last < 0)
5095 {
5096 warning (0, "unknown register name: %s", dash + 1);
5097 return;
5098 }
5099
5100 *dash = '-';
5101
5102 if (first > last)
5103 {
5104 warning (0, "%s-%s is an empty range", str, dash + 1);
5105 return;
5106 }
5107
5108 for (i = first; i <= last; ++i)
5109 fixed_regs[i] = call_used_regs[i] = 1;
5110
5111 if (!comma)
5112 break;
5113
5114 *comma = ',';
5115 str = comma + 1;
5116 }
5117 }
5118
5119 /* Return TRUE if x is a CONST_INT, CONST_DOUBLE or CONST_VECTOR that
5120 can be generated using the fsmbi instruction. */
5121 int
5122 fsmbi_const_p (rtx x)
5123 {
5124 if (CONSTANT_P (x))
5125 {
5126 /* We can always choose TImode for CONST_INT because the high bits
5127 of an SImode will always be all 1s, i.e., valid for fsmbi. */
5128 enum immediate_class c = classify_immediate (x, TImode);
5129 return c == IC_FSMBI || (!epilogue_completed && c == IC_FSMBI2);
5130 }
5131 return 0;
5132 }
5133
5134 /* Return TRUE if x is a CONST_INT, CONST_DOUBLE or CONST_VECTOR that
5135 can be generated using the cbd, chd, cwd or cdd instruction. */
5136 int
5137 cpat_const_p (rtx x, enum machine_mode mode)
5138 {
5139 if (CONSTANT_P (x))
5140 {
5141 enum immediate_class c = classify_immediate (x, mode);
5142 return c == IC_CPAT;
5143 }
5144 return 0;
5145 }
5146
5147 rtx
5148 gen_cpat_const (rtx * ops)
5149 {
5150 unsigned char dst[16];
5151 int i, offset, shift, isize;
5152 if (GET_CODE (ops[3]) != CONST_INT
5153 || GET_CODE (ops[2]) != CONST_INT
5154 || (GET_CODE (ops[1]) != CONST_INT
5155 && GET_CODE (ops[1]) != REG))
5156 return 0;
5157 if (GET_CODE (ops[1]) == REG
5158 && (!REG_POINTER (ops[1])
5159 || REGNO_POINTER_ALIGN (ORIGINAL_REGNO (ops[1])) < 128))
5160 return 0;
5161
5162 for (i = 0; i < 16; i++)
5163 dst[i] = i + 16;
5164 isize = INTVAL (ops[3]);
5165 if (isize == 1)
5166 shift = 3;
5167 else if (isize == 2)
5168 shift = 2;
5169 else
5170 shift = 0;
5171 offset = (INTVAL (ops[2]) +
5172 (GET_CODE (ops[1]) ==
5173 CONST_INT ? INTVAL (ops[1]) : 0)) & 15;
5174 for (i = 0; i < isize; i++)
5175 dst[offset + i] = i + shift;
5176 return array_to_constant (TImode, dst);
5177 }
5178
5179 /* Convert a CONST_INT, CONST_DOUBLE, or CONST_VECTOR into a 16 byte
5180 array. Use MODE for CONST_INT's. When the constant's mode is smaller
5181 than 16 bytes, the value is repeated across the rest of the array. */
5182 void
5183 constant_to_array (enum machine_mode mode, rtx x, unsigned char arr[16])
5184 {
5185 HOST_WIDE_INT val;
5186 int i, j, first;
5187
5188 memset (arr, 0, 16);
5189 mode = GET_MODE (x) != VOIDmode ? GET_MODE (x) : mode;
5190 if (GET_CODE (x) == CONST_INT
5191 || (GET_CODE (x) == CONST_DOUBLE
5192 && (mode == SFmode || mode == DFmode)))
5193 {
5194 gcc_assert (mode != VOIDmode && mode != BLKmode);
5195
5196 if (GET_CODE (x) == CONST_DOUBLE)
5197 val = const_double_to_hwint (x);
5198 else
5199 val = INTVAL (x);
5200 first = GET_MODE_SIZE (mode) - 1;
5201 for (i = first; i >= 0; i--)
5202 {
5203 arr[i] = val & 0xff;
5204 val >>= 8;
5205 }
5206 /* Splat the constant across the whole array. */
5207 for (j = 0, i = first + 1; i < 16; i++)
5208 {
5209 arr[i] = arr[j];
5210 j = (j == first) ? 0 : j + 1;
5211 }
5212 }
5213 else if (GET_CODE (x) == CONST_DOUBLE)
5214 {
5215 val = CONST_DOUBLE_LOW (x);
5216 for (i = 15; i >= 8; i--)
5217 {
5218 arr[i] = val & 0xff;
5219 val >>= 8;
5220 }
5221 val = CONST_DOUBLE_HIGH (x);
5222 for (i = 7; i >= 0; i--)
5223 {
5224 arr[i] = val & 0xff;
5225 val >>= 8;
5226 }
5227 }
5228 else if (GET_CODE (x) == CONST_VECTOR)
5229 {
5230 int units;
5231 rtx elt;
5232 mode = GET_MODE_INNER (mode);
5233 units = CONST_VECTOR_NUNITS (x);
5234 for (i = 0; i < units; i++)
5235 {
5236 elt = CONST_VECTOR_ELT (x, i);
5237 if (GET_CODE (elt) == CONST_INT || GET_CODE (elt) == CONST_DOUBLE)
5238 {
5239 if (GET_CODE (elt) == CONST_DOUBLE)
5240 val = const_double_to_hwint (elt);
5241 else
5242 val = INTVAL (elt);
5243 first = GET_MODE_SIZE (mode) - 1;
5244 if (first + i * GET_MODE_SIZE (mode) > 16)
5245 abort ();
5246 for (j = first; j >= 0; j--)
5247 {
5248 arr[j + i * GET_MODE_SIZE (mode)] = val & 0xff;
5249 val >>= 8;
5250 }
5251 }
5252 }
5253 }
5254 else
5255 gcc_unreachable();
5256 }
5257
5258 /* Convert a 16 byte array to a constant of mode MODE. When MODE is
5259 smaller than 16 bytes, use the bytes that would represent that value
5260 in a register, e.g., for QImode return the value of arr[3]. */
5261 rtx
5262 array_to_constant (enum machine_mode mode, const unsigned char arr[16])
5263 {
5264 enum machine_mode inner_mode;
5265 rtvec v;
5266 int units, size, i, j, k;
5267 HOST_WIDE_INT val;
5268
5269 if (GET_MODE_CLASS (mode) == MODE_INT
5270 && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
5271 {
5272 j = GET_MODE_SIZE (mode);
5273 i = j < 4 ? 4 - j : 0;
5274 for (val = 0; i < j; i++)
5275 val = (val << 8) | arr[i];
5276 val = trunc_int_for_mode (val, mode);
5277 return GEN_INT (val);
5278 }
5279
5280 if (mode == TImode)
5281 {
5282 HOST_WIDE_INT high;
5283 for (i = high = 0; i < 8; i++)
5284 high = (high << 8) | arr[i];
5285 for (i = 8, val = 0; i < 16; i++)
5286 val = (val << 8) | arr[i];
5287 return immed_double_const (val, high, TImode);
5288 }
5289 if (mode == SFmode)
5290 {
5291 val = (arr[0] << 24) | (arr[1] << 16) | (arr[2] << 8) | arr[3];
5292 val = trunc_int_for_mode (val, SImode);
5293 return hwint_to_const_double (SFmode, val);
5294 }
5295 if (mode == DFmode)
5296 {
5297 for (i = 0, val = 0; i < 8; i++)
5298 val = (val << 8) | arr[i];
5299 return hwint_to_const_double (DFmode, val);
5300 }
5301
5302 if (!VECTOR_MODE_P (mode))
5303 abort ();
5304
5305 units = GET_MODE_NUNITS (mode);
5306 size = GET_MODE_UNIT_SIZE (mode);
5307 inner_mode = GET_MODE_INNER (mode);
5308 v = rtvec_alloc (units);
5309
5310 for (k = i = 0; i < units; ++i)
5311 {
5312 val = 0;
5313 for (j = 0; j < size; j++, k++)
5314 val = (val << 8) | arr[k];
5315
5316 if (GET_MODE_CLASS (inner_mode) == MODE_FLOAT)
5317 RTVEC_ELT (v, i) = hwint_to_const_double (inner_mode, val);
5318 else
5319 RTVEC_ELT (v, i) = GEN_INT (trunc_int_for_mode (val, inner_mode));
5320 }
5321 if (k > 16)
5322 abort ();
5323
5324 return gen_rtx_CONST_VECTOR (mode, v);
5325 }
5326
5327 static void
5328 reloc_diagnostic (rtx x)
5329 {
5330 tree decl = 0;
5331 if (!flag_pic || !(TARGET_WARN_RELOC || TARGET_ERROR_RELOC))
5332 return;
5333
5334 if (GET_CODE (x) == SYMBOL_REF)
5335 decl = SYMBOL_REF_DECL (x);
5336 else if (GET_CODE (x) == CONST
5337 && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF)
5338 decl = SYMBOL_REF_DECL (XEXP (XEXP (x, 0), 0));
5339
5340 /* SYMBOL_REF_DECL is not necessarily a DECL. */
5341 if (decl && !DECL_P (decl))
5342 decl = 0;
5343
5344 /* The decl could be a string constant. */
5345 if (decl && DECL_P (decl))
5346 {
5347 location_t loc;
5348 /* We use last_assemble_variable_decl to get line information. It's
5349 not always going to be right and might not even be close, but will
5350 be right for the more common cases. */
5351 if (!last_assemble_variable_decl || in_section == ctors_section)
5352 loc = DECL_SOURCE_LOCATION (decl);
5353 else
5354 loc = DECL_SOURCE_LOCATION (last_assemble_variable_decl);
5355
5356 if (TARGET_WARN_RELOC)
5357 warning_at (loc, 0,
5358 "creating run-time relocation for %qD", decl);
5359 else
5360 error_at (loc,
5361 "creating run-time relocation for %qD", decl);
5362 }
5363 else
5364 {
5365 if (TARGET_WARN_RELOC)
5366 warning_at (input_location, 0, "creating run-time relocation");
5367 else
5368 error_at (input_location, "creating run-time relocation");
5369 }
5370 }
5371
5372 /* Hook into assemble_integer so we can generate an error for run-time
5373 relocations. The SPU ABI disallows them. */
5374 static bool
5375 spu_assemble_integer (rtx x, unsigned int size, int aligned_p)
5376 {
5377 /* By default run-time relocations aren't supported, but we allow them
5378 in case users support it in their own run-time loader. And we provide
5379 a warning for those users that don't. */
5380 if ((GET_CODE (x) == SYMBOL_REF)
5381 || GET_CODE (x) == LABEL_REF || GET_CODE (x) == CONST)
5382 reloc_diagnostic (x);
5383
5384 return default_assemble_integer (x, size, aligned_p);
5385 }
5386
5387 static void
5388 spu_asm_globalize_label (FILE * file, const char *name)
5389 {
5390 fputs ("\t.global\t", file);
5391 assemble_name (file, name);
5392 fputs ("\n", file);
5393 }
5394
5395 static bool
5396 spu_rtx_costs (rtx x, int code, int outer_code ATTRIBUTE_UNUSED, int *total,
5397 bool speed ATTRIBUTE_UNUSED)
5398 {
5399 enum machine_mode mode = GET_MODE (x);
5400 int cost = COSTS_N_INSNS (2);
5401
5402 /* Folding to a CONST_VECTOR will use extra space but there might
5403 be only a small savings in cycles. We'd like to use a CONST_VECTOR
5404 only if it allows us to fold away multiple insns. Changing the cost
5405 of a CONST_VECTOR here (or in CONST_COSTS) doesn't help though
5406 because this cost will only be compared against a single insn.
5407 if (code == CONST_VECTOR)
5408 return (LEGITIMATE_CONSTANT_P(x)) ? cost : COSTS_N_INSNS(6);
5409 */
5410
5411 /* Use defaults for float operations. Not accurate but good enough. */
5412 if (mode == DFmode)
5413 {
5414 *total = COSTS_N_INSNS (13);
5415 return true;
5416 }
5417 if (mode == SFmode)
5418 {
5419 *total = COSTS_N_INSNS (6);
5420 return true;
5421 }
5422 switch (code)
5423 {
5424 case CONST_INT:
5425 if (satisfies_constraint_K (x))
5426 *total = 0;
5427 else if (INTVAL (x) >= -0x80000000ll && INTVAL (x) <= 0xffffffffll)
5428 *total = COSTS_N_INSNS (1);
5429 else
5430 *total = COSTS_N_INSNS (3);
5431 return true;
5432
5433 case CONST:
5434 *total = COSTS_N_INSNS (3);
5435 return true;
5436
5437 case LABEL_REF:
5438 case SYMBOL_REF:
5439 *total = COSTS_N_INSNS (0);
5440 return true;
5441
5442 case CONST_DOUBLE:
5443 *total = COSTS_N_INSNS (5);
5444 return true;
5445
5446 case FLOAT_EXTEND:
5447 case FLOAT_TRUNCATE:
5448 case FLOAT:
5449 case UNSIGNED_FLOAT:
5450 case FIX:
5451 case UNSIGNED_FIX:
5452 *total = COSTS_N_INSNS (7);
5453 return true;
5454
5455 case PLUS:
5456 if (mode == TImode)
5457 {
5458 *total = COSTS_N_INSNS (9);
5459 return true;
5460 }
5461 break;
5462
5463 case MULT:
5464 cost =
5465 GET_CODE (XEXP (x, 0)) ==
5466 REG ? COSTS_N_INSNS (12) : COSTS_N_INSNS (7);
5467 if (mode == SImode && GET_CODE (XEXP (x, 0)) == REG)
5468 {
5469 if (GET_CODE (XEXP (x, 1)) == CONST_INT)
5470 {
5471 HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
5472 cost = COSTS_N_INSNS (14);
5473 if ((val & 0xffff) == 0)
5474 cost = COSTS_N_INSNS (9);
5475 else if (val > 0 && val < 0x10000)
5476 cost = COSTS_N_INSNS (11);
5477 }
5478 }
5479 *total = cost;
5480 return true;
5481 case DIV:
5482 case UDIV:
5483 case MOD:
5484 case UMOD:
5485 *total = COSTS_N_INSNS (20);
5486 return true;
5487 case ROTATE:
5488 case ROTATERT:
5489 case ASHIFT:
5490 case ASHIFTRT:
5491 case LSHIFTRT:
5492 *total = COSTS_N_INSNS (4);
5493 return true;
5494 case UNSPEC:
5495 if (XINT (x, 1) == UNSPEC_CONVERT)
5496 *total = COSTS_N_INSNS (0);
5497 else
5498 *total = COSTS_N_INSNS (4);
5499 return true;
5500 }
5501 /* Scale cost by mode size. Except when initializing (cfun->decl == 0). */
5502 if (GET_MODE_CLASS (mode) == MODE_INT
5503 && GET_MODE_SIZE (mode) > GET_MODE_SIZE (SImode) && cfun && cfun->decl)
5504 cost = cost * (GET_MODE_SIZE (mode) / GET_MODE_SIZE (SImode))
5505 * (GET_MODE_SIZE (mode) / GET_MODE_SIZE (SImode));
5506 *total = cost;
5507 return true;
5508 }
5509
5510 static enum machine_mode
5511 spu_unwind_word_mode (void)
5512 {
5513 return SImode;
5514 }
5515
5516 /* Decide whether we can make a sibling call to a function. DECL is the
5517 declaration of the function being targeted by the call and EXP is the
5518 CALL_EXPR representing the call. */
5519 static bool
5520 spu_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
5521 {
5522 return decl && !TARGET_LARGE_MEM;
5523 }
5524
5525 /* We need to correctly update the back chain pointer and the Available
5526 Stack Size (which is in the second slot of the sp register.) */
5527 void
5528 spu_allocate_stack (rtx op0, rtx op1)
5529 {
5530 HOST_WIDE_INT v;
5531 rtx chain = gen_reg_rtx (V4SImode);
5532 rtx stack_bot = gen_frame_mem (V4SImode, stack_pointer_rtx);
5533 rtx sp = gen_reg_rtx (V4SImode);
5534 rtx splatted = gen_reg_rtx (V4SImode);
5535 rtx pat = gen_reg_rtx (TImode);
5536
5537 /* copy the back chain so we can save it back again. */
5538 emit_move_insn (chain, stack_bot);
5539
5540 op1 = force_reg (SImode, op1);
5541
5542 v = 0x1020300010203ll;
5543 emit_move_insn (pat, immed_double_const (v, v, TImode));
5544 emit_insn (gen_shufb (splatted, op1, op1, pat));
5545
5546 emit_insn (gen_spu_convert (sp, stack_pointer_rtx));
5547 emit_insn (gen_subv4si3 (sp, sp, splatted));
5548
5549 if (flag_stack_check)
5550 {
5551 rtx avail = gen_reg_rtx(SImode);
5552 rtx result = gen_reg_rtx(SImode);
5553 emit_insn (gen_vec_extractv4si (avail, sp, GEN_INT (1)));
5554 emit_insn (gen_cgt_si(result, avail, GEN_INT (-1)));
5555 emit_insn (gen_spu_heq (result, GEN_INT(0) ));
5556 }
5557
5558 emit_insn (gen_spu_convert (stack_pointer_rtx, sp));
5559
5560 emit_move_insn (stack_bot, chain);
5561
5562 emit_move_insn (op0, virtual_stack_dynamic_rtx);
5563 }
5564
5565 void
5566 spu_restore_stack_nonlocal (rtx op0 ATTRIBUTE_UNUSED, rtx op1)
5567 {
5568 static unsigned char arr[16] =
5569 { 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3 };
5570 rtx temp = gen_reg_rtx (SImode);
5571 rtx temp2 = gen_reg_rtx (SImode);
5572 rtx temp3 = gen_reg_rtx (V4SImode);
5573 rtx temp4 = gen_reg_rtx (V4SImode);
5574 rtx pat = gen_reg_rtx (TImode);
5575 rtx sp = gen_rtx_REG (V4SImode, STACK_POINTER_REGNUM);
5576
5577 /* Restore the backchain from the first word, sp from the second. */
5578 emit_move_insn (temp2, adjust_address_nv (op1, SImode, 0));
5579 emit_move_insn (temp, adjust_address_nv (op1, SImode, 4));
5580
5581 emit_move_insn (pat, array_to_constant (TImode, arr));
5582
5583 /* Compute Available Stack Size for sp */
5584 emit_insn (gen_subsi3 (temp, temp, stack_pointer_rtx));
5585 emit_insn (gen_shufb (temp3, temp, temp, pat));
5586
5587 /* Compute Available Stack Size for back chain */
5588 emit_insn (gen_subsi3 (temp2, temp2, stack_pointer_rtx));
5589 emit_insn (gen_shufb (temp4, temp2, temp2, pat));
5590 emit_insn (gen_addv4si3 (temp4, sp, temp4));
5591
5592 emit_insn (gen_addv4si3 (sp, sp, temp3));
5593 emit_move_insn (gen_frame_mem (V4SImode, stack_pointer_rtx), temp4);
5594 }
5595
5596 static void
5597 spu_init_libfuncs (void)
5598 {
5599 set_optab_libfunc (smul_optab, DImode, "__muldi3");
5600 set_optab_libfunc (sdiv_optab, DImode, "__divdi3");
5601 set_optab_libfunc (smod_optab, DImode, "__moddi3");
5602 set_optab_libfunc (udiv_optab, DImode, "__udivdi3");
5603 set_optab_libfunc (umod_optab, DImode, "__umoddi3");
5604 set_optab_libfunc (udivmod_optab, DImode, "__udivmoddi4");
5605 set_optab_libfunc (ffs_optab, DImode, "__ffsdi2");
5606 set_optab_libfunc (clz_optab, DImode, "__clzdi2");
5607 set_optab_libfunc (ctz_optab, DImode, "__ctzdi2");
5608 set_optab_libfunc (popcount_optab, DImode, "__popcountdi2");
5609 set_optab_libfunc (parity_optab, DImode, "__paritydi2");
5610
5611 set_conv_libfunc (ufloat_optab, DFmode, SImode, "__float_unssidf");
5612 set_conv_libfunc (ufloat_optab, DFmode, DImode, "__float_unsdidf");
5613
5614 set_optab_libfunc (smul_optab, TImode, "__multi3");
5615 set_optab_libfunc (sdiv_optab, TImode, "__divti3");
5616 set_optab_libfunc (smod_optab, TImode, "__modti3");
5617 set_optab_libfunc (udiv_optab, TImode, "__udivti3");
5618 set_optab_libfunc (umod_optab, TImode, "__umodti3");
5619 set_optab_libfunc (udivmod_optab, TImode, "__udivmodti4");
5620 }
5621
5622 /* Make a subreg, stripping any existing subreg. We could possibly just
5623 call simplify_subreg, but in this case we know what we want. */
5624 rtx
5625 spu_gen_subreg (enum machine_mode mode, rtx x)
5626 {
5627 if (GET_CODE (x) == SUBREG)
5628 x = SUBREG_REG (x);
5629 if (GET_MODE (x) == mode)
5630 return x;
5631 return gen_rtx_SUBREG (mode, x, 0);
5632 }
5633
5634 static bool
5635 spu_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
5636 {
5637 return (TYPE_MODE (type) == BLKmode
5638 && ((type) == 0
5639 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
5640 || int_size_in_bytes (type) >
5641 (MAX_REGISTER_RETURN * UNITS_PER_WORD)));
5642 }
5643 \f
5644 /* Create the built-in types and functions */
5645
5646 enum spu_function_code
5647 {
5648 #define DEF_BUILTIN(fcode, icode, name, type, params) fcode,
5649 #include "spu-builtins.def"
5650 #undef DEF_BUILTIN
5651 NUM_SPU_BUILTINS
5652 };
5653
5654 extern GTY(()) struct spu_builtin_description spu_builtins[NUM_SPU_BUILTINS];
5655
5656 struct spu_builtin_description spu_builtins[] = {
5657 #define DEF_BUILTIN(fcode, icode, name, type, params) \
5658 {fcode, icode, name, type, params},
5659 #include "spu-builtins.def"
5660 #undef DEF_BUILTIN
5661 };
5662
5663 static GTY(()) tree spu_builtin_decls[NUM_SPU_BUILTINS];
5664
5665 /* Returns the spu builtin decl for CODE. */
5666
5667 static tree
5668 spu_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
5669 {
5670 if (code >= NUM_SPU_BUILTINS)
5671 return error_mark_node;
5672
5673 return spu_builtin_decls[code];
5674 }
5675
5676
5677 static void
5678 spu_init_builtins (void)
5679 {
5680 struct spu_builtin_description *d;
5681 unsigned int i;
5682
5683 V16QI_type_node = build_vector_type (intQI_type_node, 16);
5684 V8HI_type_node = build_vector_type (intHI_type_node, 8);
5685 V4SI_type_node = build_vector_type (intSI_type_node, 4);
5686 V2DI_type_node = build_vector_type (intDI_type_node, 2);
5687 V4SF_type_node = build_vector_type (float_type_node, 4);
5688 V2DF_type_node = build_vector_type (double_type_node, 2);
5689
5690 unsigned_V16QI_type_node = build_vector_type (unsigned_intQI_type_node, 16);
5691 unsigned_V8HI_type_node = build_vector_type (unsigned_intHI_type_node, 8);
5692 unsigned_V4SI_type_node = build_vector_type (unsigned_intSI_type_node, 4);
5693 unsigned_V2DI_type_node = build_vector_type (unsigned_intDI_type_node, 2);
5694
5695 spu_builtin_types[SPU_BTI_QUADWORD] = V16QI_type_node;
5696
5697 spu_builtin_types[SPU_BTI_7] = global_trees[TI_INTSI_TYPE];
5698 spu_builtin_types[SPU_BTI_S7] = global_trees[TI_INTSI_TYPE];
5699 spu_builtin_types[SPU_BTI_U7] = global_trees[TI_INTSI_TYPE];
5700 spu_builtin_types[SPU_BTI_S10] = global_trees[TI_INTSI_TYPE];
5701 spu_builtin_types[SPU_BTI_S10_4] = global_trees[TI_INTSI_TYPE];
5702 spu_builtin_types[SPU_BTI_U14] = global_trees[TI_INTSI_TYPE];
5703 spu_builtin_types[SPU_BTI_16] = global_trees[TI_INTSI_TYPE];
5704 spu_builtin_types[SPU_BTI_S16] = global_trees[TI_INTSI_TYPE];
5705 spu_builtin_types[SPU_BTI_S16_2] = global_trees[TI_INTSI_TYPE];
5706 spu_builtin_types[SPU_BTI_U16] = global_trees[TI_INTSI_TYPE];
5707 spu_builtin_types[SPU_BTI_U16_2] = global_trees[TI_INTSI_TYPE];
5708 spu_builtin_types[SPU_BTI_U18] = global_trees[TI_INTSI_TYPE];
5709
5710 spu_builtin_types[SPU_BTI_INTQI] = global_trees[TI_INTQI_TYPE];
5711 spu_builtin_types[SPU_BTI_INTHI] = global_trees[TI_INTHI_TYPE];
5712 spu_builtin_types[SPU_BTI_INTSI] = global_trees[TI_INTSI_TYPE];
5713 spu_builtin_types[SPU_BTI_INTDI] = global_trees[TI_INTDI_TYPE];
5714 spu_builtin_types[SPU_BTI_UINTQI] = global_trees[TI_UINTQI_TYPE];
5715 spu_builtin_types[SPU_BTI_UINTHI] = global_trees[TI_UINTHI_TYPE];
5716 spu_builtin_types[SPU_BTI_UINTSI] = global_trees[TI_UINTSI_TYPE];
5717 spu_builtin_types[SPU_BTI_UINTDI] = global_trees[TI_UINTDI_TYPE];
5718
5719 spu_builtin_types[SPU_BTI_FLOAT] = global_trees[TI_FLOAT_TYPE];
5720 spu_builtin_types[SPU_BTI_DOUBLE] = global_trees[TI_DOUBLE_TYPE];
5721
5722 spu_builtin_types[SPU_BTI_VOID] = global_trees[TI_VOID_TYPE];
5723
5724 spu_builtin_types[SPU_BTI_PTR] =
5725 build_pointer_type (build_qualified_type
5726 (void_type_node,
5727 TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE));
5728
5729 /* For each builtin we build a new prototype. The tree code will make
5730 sure nodes are shared. */
5731 for (i = 0, d = spu_builtins; i < NUM_SPU_BUILTINS; i++, d++)
5732 {
5733 tree p;
5734 char name[64]; /* build_function will make a copy. */
5735 int parm;
5736
5737 if (d->name == 0)
5738 continue;
5739
5740 /* Find last parm. */
5741 for (parm = 1; d->parm[parm] != SPU_BTI_END_OF_PARAMS; parm++)
5742 ;
5743
5744 p = void_list_node;
5745 while (parm > 1)
5746 p = tree_cons (NULL_TREE, spu_builtin_types[d->parm[--parm]], p);
5747
5748 p = build_function_type (spu_builtin_types[d->parm[0]], p);
5749
5750 sprintf (name, "__builtin_%s", d->name);
5751 spu_builtin_decls[i] =
5752 add_builtin_function (name, p, i, BUILT_IN_MD, NULL, NULL_TREE);
5753 if (d->fcode == SPU_MASK_FOR_LOAD)
5754 TREE_READONLY (spu_builtin_decls[i]) = 1;
5755
5756 /* These builtins don't throw. */
5757 TREE_NOTHROW (spu_builtin_decls[i]) = 1;
5758 }
5759 }
5760
5761 void
5762 spu_restore_stack_block (rtx op0 ATTRIBUTE_UNUSED, rtx op1)
5763 {
5764 static unsigned char arr[16] =
5765 { 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3 };
5766
5767 rtx temp = gen_reg_rtx (Pmode);
5768 rtx temp2 = gen_reg_rtx (V4SImode);
5769 rtx temp3 = gen_reg_rtx (V4SImode);
5770 rtx pat = gen_reg_rtx (TImode);
5771 rtx sp = gen_rtx_REG (V4SImode, STACK_POINTER_REGNUM);
5772
5773 emit_move_insn (pat, array_to_constant (TImode, arr));
5774
5775 /* Restore the sp. */
5776 emit_move_insn (temp, op1);
5777 emit_move_insn (temp2, gen_frame_mem (V4SImode, stack_pointer_rtx));
5778
5779 /* Compute available stack size for sp. */
5780 emit_insn (gen_subsi3 (temp, temp, stack_pointer_rtx));
5781 emit_insn (gen_shufb (temp3, temp, temp, pat));
5782
5783 emit_insn (gen_addv4si3 (sp, sp, temp3));
5784 emit_move_insn (gen_frame_mem (V4SImode, stack_pointer_rtx), temp2);
5785 }
5786
5787 int
5788 spu_safe_dma (HOST_WIDE_INT channel)
5789 {
5790 return TARGET_SAFE_DMA && channel >= 21 && channel <= 27;
5791 }
5792
5793 void
5794 spu_builtin_splats (rtx ops[])
5795 {
5796 enum machine_mode mode = GET_MODE (ops[0]);
5797 if (GET_CODE (ops[1]) == CONST_INT || GET_CODE (ops[1]) == CONST_DOUBLE)
5798 {
5799 unsigned char arr[16];
5800 constant_to_array (GET_MODE_INNER (mode), ops[1], arr);
5801 emit_move_insn (ops[0], array_to_constant (mode, arr));
5802 }
5803 else
5804 {
5805 rtx reg = gen_reg_rtx (TImode);
5806 rtx shuf;
5807 if (GET_CODE (ops[1]) != REG
5808 && GET_CODE (ops[1]) != SUBREG)
5809 ops[1] = force_reg (GET_MODE_INNER (mode), ops[1]);
5810 switch (mode)
5811 {
5812 case V2DImode:
5813 case V2DFmode:
5814 shuf =
5815 immed_double_const (0x0001020304050607ll, 0x1011121314151617ll,
5816 TImode);
5817 break;
5818 case V4SImode:
5819 case V4SFmode:
5820 shuf =
5821 immed_double_const (0x0001020300010203ll, 0x0001020300010203ll,
5822 TImode);
5823 break;
5824 case V8HImode:
5825 shuf =
5826 immed_double_const (0x0203020302030203ll, 0x0203020302030203ll,
5827 TImode);
5828 break;
5829 case V16QImode:
5830 shuf =
5831 immed_double_const (0x0303030303030303ll, 0x0303030303030303ll,
5832 TImode);
5833 break;
5834 default:
5835 abort ();
5836 }
5837 emit_move_insn (reg, shuf);
5838 emit_insn (gen_shufb (ops[0], ops[1], ops[1], reg));
5839 }
5840 }
5841
5842 void
5843 spu_builtin_extract (rtx ops[])
5844 {
5845 enum machine_mode mode;
5846 rtx rot, from, tmp;
5847
5848 mode = GET_MODE (ops[1]);
5849
5850 if (GET_CODE (ops[2]) == CONST_INT)
5851 {
5852 switch (mode)
5853 {
5854 case V16QImode:
5855 emit_insn (gen_vec_extractv16qi (ops[0], ops[1], ops[2]));
5856 break;
5857 case V8HImode:
5858 emit_insn (gen_vec_extractv8hi (ops[0], ops[1], ops[2]));
5859 break;
5860 case V4SFmode:
5861 emit_insn (gen_vec_extractv4sf (ops[0], ops[1], ops[2]));
5862 break;
5863 case V4SImode:
5864 emit_insn (gen_vec_extractv4si (ops[0], ops[1], ops[2]));
5865 break;
5866 case V2DImode:
5867 emit_insn (gen_vec_extractv2di (ops[0], ops[1], ops[2]));
5868 break;
5869 case V2DFmode:
5870 emit_insn (gen_vec_extractv2df (ops[0], ops[1], ops[2]));
5871 break;
5872 default:
5873 abort ();
5874 }
5875 return;
5876 }
5877
5878 from = spu_gen_subreg (TImode, ops[1]);
5879 rot = gen_reg_rtx (TImode);
5880 tmp = gen_reg_rtx (SImode);
5881
5882 switch (mode)
5883 {
5884 case V16QImode:
5885 emit_insn (gen_addsi3 (tmp, ops[2], GEN_INT (-3)));
5886 break;
5887 case V8HImode:
5888 emit_insn (gen_addsi3 (tmp, ops[2], ops[2]));
5889 emit_insn (gen_addsi3 (tmp, tmp, GEN_INT (-2)));
5890 break;
5891 case V4SFmode:
5892 case V4SImode:
5893 emit_insn (gen_ashlsi3 (tmp, ops[2], GEN_INT (2)));
5894 break;
5895 case V2DImode:
5896 case V2DFmode:
5897 emit_insn (gen_ashlsi3 (tmp, ops[2], GEN_INT (3)));
5898 break;
5899 default:
5900 abort ();
5901 }
5902 emit_insn (gen_rotqby_ti (rot, from, tmp));
5903
5904 emit_insn (gen_spu_convert (ops[0], rot));
5905 }
5906
5907 void
5908 spu_builtin_insert (rtx ops[])
5909 {
5910 enum machine_mode mode = GET_MODE (ops[0]);
5911 enum machine_mode imode = GET_MODE_INNER (mode);
5912 rtx mask = gen_reg_rtx (TImode);
5913 rtx offset;
5914
5915 if (GET_CODE (ops[3]) == CONST_INT)
5916 offset = GEN_INT (INTVAL (ops[3]) * GET_MODE_SIZE (imode));
5917 else
5918 {
5919 offset = gen_reg_rtx (SImode);
5920 emit_insn (gen_mulsi3
5921 (offset, ops[3], GEN_INT (GET_MODE_SIZE (imode))));
5922 }
5923 emit_insn (gen_cpat
5924 (mask, stack_pointer_rtx, offset,
5925 GEN_INT (GET_MODE_SIZE (imode))));
5926 emit_insn (gen_shufb (ops[0], ops[1], ops[2], mask));
5927 }
5928
5929 void
5930 spu_builtin_promote (rtx ops[])
5931 {
5932 enum machine_mode mode, imode;
5933 rtx rot, from, offset;
5934 HOST_WIDE_INT pos;
5935
5936 mode = GET_MODE (ops[0]);
5937 imode = GET_MODE_INNER (mode);
5938
5939 from = gen_reg_rtx (TImode);
5940 rot = spu_gen_subreg (TImode, ops[0]);
5941
5942 emit_insn (gen_spu_convert (from, ops[1]));
5943
5944 if (GET_CODE (ops[2]) == CONST_INT)
5945 {
5946 pos = -GET_MODE_SIZE (imode) * INTVAL (ops[2]);
5947 if (GET_MODE_SIZE (imode) < 4)
5948 pos += 4 - GET_MODE_SIZE (imode);
5949 offset = GEN_INT (pos & 15);
5950 }
5951 else
5952 {
5953 offset = gen_reg_rtx (SImode);
5954 switch (mode)
5955 {
5956 case V16QImode:
5957 emit_insn (gen_subsi3 (offset, GEN_INT (3), ops[2]));
5958 break;
5959 case V8HImode:
5960 emit_insn (gen_subsi3 (offset, GEN_INT (1), ops[2]));
5961 emit_insn (gen_addsi3 (offset, offset, offset));
5962 break;
5963 case V4SFmode:
5964 case V4SImode:
5965 emit_insn (gen_subsi3 (offset, GEN_INT (0), ops[2]));
5966 emit_insn (gen_ashlsi3 (offset, offset, GEN_INT (2)));
5967 break;
5968 case V2DImode:
5969 case V2DFmode:
5970 emit_insn (gen_ashlsi3 (offset, ops[2], GEN_INT (3)));
5971 break;
5972 default:
5973 abort ();
5974 }
5975 }
5976 emit_insn (gen_rotqby_ti (rot, from, offset));
5977 }
5978
5979 static void
5980 spu_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
5981 {
5982 rtx fnaddr = XEXP (DECL_RTL (fndecl), 0);
5983 rtx shuf = gen_reg_rtx (V4SImode);
5984 rtx insn = gen_reg_rtx (V4SImode);
5985 rtx shufc;
5986 rtx insnc;
5987 rtx mem;
5988
5989 fnaddr = force_reg (SImode, fnaddr);
5990 cxt = force_reg (SImode, cxt);
5991
5992 if (TARGET_LARGE_MEM)
5993 {
5994 rtx rotl = gen_reg_rtx (V4SImode);
5995 rtx mask = gen_reg_rtx (V4SImode);
5996 rtx bi = gen_reg_rtx (SImode);
5997 static unsigned char const shufa[16] = {
5998 2, 3, 0, 1, 18, 19, 16, 17,
5999 0, 1, 2, 3, 16, 17, 18, 19
6000 };
6001 static unsigned char const insna[16] = {
6002 0x41, 0, 0, 79,
6003 0x41, 0, 0, STATIC_CHAIN_REGNUM,
6004 0x60, 0x80, 0, 79,
6005 0x60, 0x80, 0, STATIC_CHAIN_REGNUM
6006 };
6007
6008 shufc = force_reg (TImode, array_to_constant (TImode, shufa));
6009 insnc = force_reg (V4SImode, array_to_constant (V4SImode, insna));
6010
6011 emit_insn (gen_shufb (shuf, fnaddr, cxt, shufc));
6012 emit_insn (gen_vrotlv4si3 (rotl, shuf, spu_const (V4SImode, 7)));
6013 emit_insn (gen_movv4si (mask, spu_const (V4SImode, 0xffff << 7)));
6014 emit_insn (gen_selb (insn, insnc, rotl, mask));
6015
6016 mem = adjust_address (m_tramp, V4SImode, 0);
6017 emit_move_insn (mem, insn);
6018
6019 emit_move_insn (bi, GEN_INT (0x35000000 + (79 << 7)));
6020 mem = adjust_address (m_tramp, Pmode, 16);
6021 emit_move_insn (mem, bi);
6022 }
6023 else
6024 {
6025 rtx scxt = gen_reg_rtx (SImode);
6026 rtx sfnaddr = gen_reg_rtx (SImode);
6027 static unsigned char const insna[16] = {
6028 0x42, 0, 0, STATIC_CHAIN_REGNUM,
6029 0x30, 0, 0, 0,
6030 0, 0, 0, 0,
6031 0, 0, 0, 0
6032 };
6033
6034 shufc = gen_reg_rtx (TImode);
6035 insnc = force_reg (V4SImode, array_to_constant (V4SImode, insna));
6036
6037 /* By or'ing all of cxt with the ila opcode we are assuming cxt
6038 fits 18 bits and the last 4 are zeros. This will be true if
6039 the stack pointer is initialized to 0x3fff0 at program start,
6040 otherwise the ila instruction will be garbage. */
6041
6042 emit_insn (gen_ashlsi3 (scxt, cxt, GEN_INT (7)));
6043 emit_insn (gen_ashlsi3 (sfnaddr, fnaddr, GEN_INT (5)));
6044 emit_insn (gen_cpat
6045 (shufc, stack_pointer_rtx, GEN_INT (4), GEN_INT (4)));
6046 emit_insn (gen_shufb (shuf, sfnaddr, scxt, shufc));
6047 emit_insn (gen_iorv4si3 (insn, insnc, shuf));
6048
6049 mem = adjust_address (m_tramp, V4SImode, 0);
6050 emit_move_insn (mem, insn);
6051 }
6052 emit_insn (gen_sync ());
6053 }
6054
6055 void
6056 spu_expand_sign_extend (rtx ops[])
6057 {
6058 unsigned char arr[16];
6059 rtx pat = gen_reg_rtx (TImode);
6060 rtx sign, c;
6061 int i, last;
6062 last = GET_MODE (ops[0]) == DImode ? 7 : 15;
6063 if (GET_MODE (ops[1]) == QImode)
6064 {
6065 sign = gen_reg_rtx (HImode);
6066 emit_insn (gen_extendqihi2 (sign, ops[1]));
6067 for (i = 0; i < 16; i++)
6068 arr[i] = 0x12;
6069 arr[last] = 0x13;
6070 }
6071 else
6072 {
6073 for (i = 0; i < 16; i++)
6074 arr[i] = 0x10;
6075 switch (GET_MODE (ops[1]))
6076 {
6077 case HImode:
6078 sign = gen_reg_rtx (SImode);
6079 emit_insn (gen_extendhisi2 (sign, ops[1]));
6080 arr[last] = 0x03;
6081 arr[last - 1] = 0x02;
6082 break;
6083 case SImode:
6084 sign = gen_reg_rtx (SImode);
6085 emit_insn (gen_ashrsi3 (sign, ops[1], GEN_INT (31)));
6086 for (i = 0; i < 4; i++)
6087 arr[last - i] = 3 - i;
6088 break;
6089 case DImode:
6090 sign = gen_reg_rtx (SImode);
6091 c = gen_reg_rtx (SImode);
6092 emit_insn (gen_spu_convert (c, ops[1]));
6093 emit_insn (gen_ashrsi3 (sign, c, GEN_INT (31)));
6094 for (i = 0; i < 8; i++)
6095 arr[last - i] = 7 - i;
6096 break;
6097 default:
6098 abort ();
6099 }
6100 }
6101 emit_move_insn (pat, array_to_constant (TImode, arr));
6102 emit_insn (gen_shufb (ops[0], ops[1], sign, pat));
6103 }
6104
6105 /* expand vector initialization. If there are any constant parts,
6106 load constant parts first. Then load any non-constant parts. */
6107 void
6108 spu_expand_vector_init (rtx target, rtx vals)
6109 {
6110 enum machine_mode mode = GET_MODE (target);
6111 int n_elts = GET_MODE_NUNITS (mode);
6112 int n_var = 0;
6113 bool all_same = true;
6114 rtx first, x = NULL_RTX, first_constant = NULL_RTX;
6115 int i;
6116
6117 first = XVECEXP (vals, 0, 0);
6118 for (i = 0; i < n_elts; ++i)
6119 {
6120 x = XVECEXP (vals, 0, i);
6121 if (!(CONST_INT_P (x)
6122 || GET_CODE (x) == CONST_DOUBLE
6123 || GET_CODE (x) == CONST_FIXED))
6124 ++n_var;
6125 else
6126 {
6127 if (first_constant == NULL_RTX)
6128 first_constant = x;
6129 }
6130 if (i > 0 && !rtx_equal_p (x, first))
6131 all_same = false;
6132 }
6133
6134 /* if all elements are the same, use splats to repeat elements */
6135 if (all_same)
6136 {
6137 if (!CONSTANT_P (first)
6138 && !register_operand (first, GET_MODE (x)))
6139 first = force_reg (GET_MODE (first), first);
6140 emit_insn (gen_spu_splats (target, first));
6141 return;
6142 }
6143
6144 /* load constant parts */
6145 if (n_var != n_elts)
6146 {
6147 if (n_var == 0)
6148 {
6149 emit_move_insn (target,
6150 gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
6151 }
6152 else
6153 {
6154 rtx constant_parts_rtx = copy_rtx (vals);
6155
6156 gcc_assert (first_constant != NULL_RTX);
6157 /* fill empty slots with the first constant, this increases
6158 our chance of using splats in the recursive call below. */
6159 for (i = 0; i < n_elts; ++i)
6160 {
6161 x = XVECEXP (constant_parts_rtx, 0, i);
6162 if (!(CONST_INT_P (x)
6163 || GET_CODE (x) == CONST_DOUBLE
6164 || GET_CODE (x) == CONST_FIXED))
6165 XVECEXP (constant_parts_rtx, 0, i) = first_constant;
6166 }
6167
6168 spu_expand_vector_init (target, constant_parts_rtx);
6169 }
6170 }
6171
6172 /* load variable parts */
6173 if (n_var != 0)
6174 {
6175 rtx insert_operands[4];
6176
6177 insert_operands[0] = target;
6178 insert_operands[2] = target;
6179 for (i = 0; i < n_elts; ++i)
6180 {
6181 x = XVECEXP (vals, 0, i);
6182 if (!(CONST_INT_P (x)
6183 || GET_CODE (x) == CONST_DOUBLE
6184 || GET_CODE (x) == CONST_FIXED))
6185 {
6186 if (!register_operand (x, GET_MODE (x)))
6187 x = force_reg (GET_MODE (x), x);
6188 insert_operands[1] = x;
6189 insert_operands[3] = GEN_INT (i);
6190 spu_builtin_insert (insert_operands);
6191 }
6192 }
6193 }
6194 }
6195
6196 /* Return insn index for the vector compare instruction for given CODE,
6197 and DEST_MODE, OP_MODE. Return -1 if valid insn is not available. */
6198
6199 static int
6200 get_vec_cmp_insn (enum rtx_code code,
6201 enum machine_mode dest_mode,
6202 enum machine_mode op_mode)
6203
6204 {
6205 switch (code)
6206 {
6207 case EQ:
6208 if (dest_mode == V16QImode && op_mode == V16QImode)
6209 return CODE_FOR_ceq_v16qi;
6210 if (dest_mode == V8HImode && op_mode == V8HImode)
6211 return CODE_FOR_ceq_v8hi;
6212 if (dest_mode == V4SImode && op_mode == V4SImode)
6213 return CODE_FOR_ceq_v4si;
6214 if (dest_mode == V4SImode && op_mode == V4SFmode)
6215 return CODE_FOR_ceq_v4sf;
6216 if (dest_mode == V2DImode && op_mode == V2DFmode)
6217 return CODE_FOR_ceq_v2df;
6218 break;
6219 case GT:
6220 if (dest_mode == V16QImode && op_mode == V16QImode)
6221 return CODE_FOR_cgt_v16qi;
6222 if (dest_mode == V8HImode && op_mode == V8HImode)
6223 return CODE_FOR_cgt_v8hi;
6224 if (dest_mode == V4SImode && op_mode == V4SImode)
6225 return CODE_FOR_cgt_v4si;
6226 if (dest_mode == V4SImode && op_mode == V4SFmode)
6227 return CODE_FOR_cgt_v4sf;
6228 if (dest_mode == V2DImode && op_mode == V2DFmode)
6229 return CODE_FOR_cgt_v2df;
6230 break;
6231 case GTU:
6232 if (dest_mode == V16QImode && op_mode == V16QImode)
6233 return CODE_FOR_clgt_v16qi;
6234 if (dest_mode == V8HImode && op_mode == V8HImode)
6235 return CODE_FOR_clgt_v8hi;
6236 if (dest_mode == V4SImode && op_mode == V4SImode)
6237 return CODE_FOR_clgt_v4si;
6238 break;
6239 default:
6240 break;
6241 }
6242 return -1;
6243 }
6244
6245 /* Emit vector compare for operands OP0 and OP1 using code RCODE.
6246 DMODE is expected destination mode. This is a recursive function. */
6247
6248 static rtx
6249 spu_emit_vector_compare (enum rtx_code rcode,
6250 rtx op0, rtx op1,
6251 enum machine_mode dmode)
6252 {
6253 int vec_cmp_insn;
6254 rtx mask;
6255 enum machine_mode dest_mode;
6256 enum machine_mode op_mode = GET_MODE (op1);
6257
6258 gcc_assert (GET_MODE (op0) == GET_MODE (op1));
6259
6260 /* Floating point vector compare instructions uses destination V4SImode.
6261 Double floating point vector compare instructions uses destination V2DImode.
6262 Move destination to appropriate mode later. */
6263 if (dmode == V4SFmode)
6264 dest_mode = V4SImode;
6265 else if (dmode == V2DFmode)
6266 dest_mode = V2DImode;
6267 else
6268 dest_mode = dmode;
6269
6270 mask = gen_reg_rtx (dest_mode);
6271 vec_cmp_insn = get_vec_cmp_insn (rcode, dest_mode, op_mode);
6272
6273 if (vec_cmp_insn == -1)
6274 {
6275 bool swap_operands = false;
6276 bool try_again = false;
6277 switch (rcode)
6278 {
6279 case LT:
6280 rcode = GT;
6281 swap_operands = true;
6282 try_again = true;
6283 break;
6284 case LTU:
6285 rcode = GTU;
6286 swap_operands = true;
6287 try_again = true;
6288 break;
6289 case NE:
6290 /* Treat A != B as ~(A==B). */
6291 {
6292 enum insn_code nor_code;
6293 rtx eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
6294 nor_code = optab_handler (one_cmpl_optab, dest_mode);
6295 gcc_assert (nor_code != CODE_FOR_nothing);
6296 emit_insn (GEN_FCN (nor_code) (mask, eq_rtx));
6297 if (dmode != dest_mode)
6298 {
6299 rtx temp = gen_reg_rtx (dest_mode);
6300 convert_move (temp, mask, 0);
6301 return temp;
6302 }
6303 return mask;
6304 }
6305 break;
6306 case GE:
6307 case GEU:
6308 case LE:
6309 case LEU:
6310 /* Try GT/GTU/LT/LTU OR EQ */
6311 {
6312 rtx c_rtx, eq_rtx;
6313 enum insn_code ior_code;
6314 enum rtx_code new_code;
6315
6316 switch (rcode)
6317 {
6318 case GE: new_code = GT; break;
6319 case GEU: new_code = GTU; break;
6320 case LE: new_code = LT; break;
6321 case LEU: new_code = LTU; break;
6322 default:
6323 gcc_unreachable ();
6324 }
6325
6326 c_rtx = spu_emit_vector_compare (new_code, op0, op1, dest_mode);
6327 eq_rtx = spu_emit_vector_compare (EQ, op0, op1, dest_mode);
6328
6329 ior_code = optab_handler (ior_optab, dest_mode);
6330 gcc_assert (ior_code != CODE_FOR_nothing);
6331 emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
6332 if (dmode != dest_mode)
6333 {
6334 rtx temp = gen_reg_rtx (dest_mode);
6335 convert_move (temp, mask, 0);
6336 return temp;
6337 }
6338 return mask;
6339 }
6340 break;
6341 default:
6342 gcc_unreachable ();
6343 }
6344
6345 /* You only get two chances. */
6346 if (try_again)
6347 vec_cmp_insn = get_vec_cmp_insn (rcode, dest_mode, op_mode);
6348
6349 gcc_assert (vec_cmp_insn != -1);
6350
6351 if (swap_operands)
6352 {
6353 rtx tmp;
6354 tmp = op0;
6355 op0 = op1;
6356 op1 = tmp;
6357 }
6358 }
6359
6360 emit_insn (GEN_FCN (vec_cmp_insn) (mask, op0, op1));
6361 if (dmode != dest_mode)
6362 {
6363 rtx temp = gen_reg_rtx (dest_mode);
6364 convert_move (temp, mask, 0);
6365 return temp;
6366 }
6367 return mask;
6368 }
6369
6370
6371 /* Emit vector conditional expression.
6372 DEST is destination. OP1 and OP2 are two VEC_COND_EXPR operands.
6373 CC_OP0 and CC_OP1 are the two operands for the relation operation COND. */
6374
6375 int
6376 spu_emit_vector_cond_expr (rtx dest, rtx op1, rtx op2,
6377 rtx cond, rtx cc_op0, rtx cc_op1)
6378 {
6379 enum machine_mode dest_mode = GET_MODE (dest);
6380 enum rtx_code rcode = GET_CODE (cond);
6381 rtx mask;
6382
6383 /* Get the vector mask for the given relational operations. */
6384 mask = spu_emit_vector_compare (rcode, cc_op0, cc_op1, dest_mode);
6385
6386 emit_insn(gen_selb (dest, op2, op1, mask));
6387
6388 return 1;
6389 }
6390
6391 static rtx
6392 spu_force_reg (enum machine_mode mode, rtx op)
6393 {
6394 rtx x, r;
6395 if (GET_MODE (op) == VOIDmode || GET_MODE (op) == BLKmode)
6396 {
6397 if ((SCALAR_INT_MODE_P (mode) && GET_CODE (op) == CONST_INT)
6398 || GET_MODE (op) == BLKmode)
6399 return force_reg (mode, convert_to_mode (mode, op, 0));
6400 abort ();
6401 }
6402
6403 r = force_reg (GET_MODE (op), op);
6404 if (GET_MODE_SIZE (GET_MODE (op)) == GET_MODE_SIZE (mode))
6405 {
6406 x = simplify_gen_subreg (mode, r, GET_MODE (op), 0);
6407 if (x)
6408 return x;
6409 }
6410
6411 x = gen_reg_rtx (mode);
6412 emit_insn (gen_spu_convert (x, r));
6413 return x;
6414 }
6415
6416 static void
6417 spu_check_builtin_parm (struct spu_builtin_description *d, rtx op, int p)
6418 {
6419 HOST_WIDE_INT v = 0;
6420 int lsbits;
6421 /* Check the range of immediate operands. */
6422 if (p >= SPU_BTI_7 && p <= SPU_BTI_U18)
6423 {
6424 int range = p - SPU_BTI_7;
6425
6426 if (!CONSTANT_P (op))
6427 error ("%s expects an integer literal in the range [%d, %d].",
6428 d->name,
6429 spu_builtin_range[range].low, spu_builtin_range[range].high);
6430
6431 if (GET_CODE (op) == CONST
6432 && (GET_CODE (XEXP (op, 0)) == PLUS
6433 || GET_CODE (XEXP (op, 0)) == MINUS))
6434 {
6435 v = INTVAL (XEXP (XEXP (op, 0), 1));
6436 op = XEXP (XEXP (op, 0), 0);
6437 }
6438 else if (GET_CODE (op) == CONST_INT)
6439 v = INTVAL (op);
6440 else if (GET_CODE (op) == CONST_VECTOR
6441 && GET_CODE (CONST_VECTOR_ELT (op, 0)) == CONST_INT)
6442 v = INTVAL (CONST_VECTOR_ELT (op, 0));
6443
6444 /* The default for v is 0 which is valid in every range. */
6445 if (v < spu_builtin_range[range].low
6446 || v > spu_builtin_range[range].high)
6447 error ("%s expects an integer literal in the range [%d, %d]. ("
6448 HOST_WIDE_INT_PRINT_DEC ")",
6449 d->name,
6450 spu_builtin_range[range].low, spu_builtin_range[range].high,
6451 v);
6452
6453 switch (p)
6454 {
6455 case SPU_BTI_S10_4:
6456 lsbits = 4;
6457 break;
6458 case SPU_BTI_U16_2:
6459 /* This is only used in lqa, and stqa. Even though the insns
6460 encode 16 bits of the address (all but the 2 least
6461 significant), only 14 bits are used because it is masked to
6462 be 16 byte aligned. */
6463 lsbits = 4;
6464 break;
6465 case SPU_BTI_S16_2:
6466 /* This is used for lqr and stqr. */
6467 lsbits = 2;
6468 break;
6469 default:
6470 lsbits = 0;
6471 }
6472
6473 if (GET_CODE (op) == LABEL_REF
6474 || (GET_CODE (op) == SYMBOL_REF
6475 && SYMBOL_REF_FUNCTION_P (op))
6476 || (v & ((1 << lsbits) - 1)) != 0)
6477 warning (0, "%d least significant bits of %s are ignored.", lsbits,
6478 d->name);
6479 }
6480 }
6481
6482
6483 static int
6484 expand_builtin_args (struct spu_builtin_description *d, tree exp,
6485 rtx target, rtx ops[])
6486 {
6487 enum insn_code icode = (enum insn_code) d->icode;
6488 int i = 0, a;
6489
6490 /* Expand the arguments into rtl. */
6491
6492 if (d->parm[0] != SPU_BTI_VOID)
6493 ops[i++] = target;
6494
6495 for (a = 0; d->parm[a+1] != SPU_BTI_END_OF_PARAMS; i++, a++)
6496 {
6497 tree arg = CALL_EXPR_ARG (exp, a);
6498 if (arg == 0)
6499 abort ();
6500 ops[i] = expand_expr (arg, NULL_RTX, VOIDmode, EXPAND_NORMAL);
6501 }
6502
6503 /* The insn pattern may have additional operands (SCRATCH).
6504 Return the number of actual non-SCRATCH operands. */
6505 gcc_assert (i <= insn_data[icode].n_operands);
6506 return i;
6507 }
6508
6509 static rtx
6510 spu_expand_builtin_1 (struct spu_builtin_description *d,
6511 tree exp, rtx target)
6512 {
6513 rtx pat;
6514 rtx ops[8];
6515 enum insn_code icode = (enum insn_code) d->icode;
6516 enum machine_mode mode, tmode;
6517 int i, p;
6518 int n_operands;
6519 tree return_type;
6520
6521 /* Set up ops[] with values from arglist. */
6522 n_operands = expand_builtin_args (d, exp, target, ops);
6523
6524 /* Handle the target operand which must be operand 0. */
6525 i = 0;
6526 if (d->parm[0] != SPU_BTI_VOID)
6527 {
6528
6529 /* We prefer the mode specified for the match_operand otherwise
6530 use the mode from the builtin function prototype. */
6531 tmode = insn_data[d->icode].operand[0].mode;
6532 if (tmode == VOIDmode)
6533 tmode = TYPE_MODE (spu_builtin_types[d->parm[0]]);
6534
6535 /* Try to use target because not using it can lead to extra copies
6536 and when we are using all of the registers extra copies leads
6537 to extra spills. */
6538 if (target && GET_CODE (target) == REG && GET_MODE (target) == tmode)
6539 ops[0] = target;
6540 else
6541 target = ops[0] = gen_reg_rtx (tmode);
6542
6543 if (!(*insn_data[icode].operand[0].predicate) (ops[0], tmode))
6544 abort ();
6545
6546 i++;
6547 }
6548
6549 if (d->fcode == SPU_MASK_FOR_LOAD)
6550 {
6551 enum machine_mode mode = insn_data[icode].operand[1].mode;
6552 tree arg;
6553 rtx addr, op, pat;
6554
6555 /* get addr */
6556 arg = CALL_EXPR_ARG (exp, 0);
6557 gcc_assert (POINTER_TYPE_P (TREE_TYPE (arg)));
6558 op = expand_expr (arg, NULL_RTX, Pmode, EXPAND_NORMAL);
6559 addr = memory_address (mode, op);
6560
6561 /* negate addr */
6562 op = gen_reg_rtx (GET_MODE (addr));
6563 emit_insn (gen_rtx_SET (VOIDmode, op,
6564 gen_rtx_NEG (GET_MODE (addr), addr)));
6565 op = gen_rtx_MEM (mode, op);
6566
6567 pat = GEN_FCN (icode) (target, op);
6568 if (!pat)
6569 return 0;
6570 emit_insn (pat);
6571 return target;
6572 }
6573
6574 /* Ignore align_hint, but still expand it's args in case they have
6575 side effects. */
6576 if (icode == CODE_FOR_spu_align_hint)
6577 return 0;
6578
6579 /* Handle the rest of the operands. */
6580 for (p = 1; i < n_operands; i++, p++)
6581 {
6582 if (insn_data[d->icode].operand[i].mode != VOIDmode)
6583 mode = insn_data[d->icode].operand[i].mode;
6584 else
6585 mode = TYPE_MODE (spu_builtin_types[d->parm[i]]);
6586
6587 /* mode can be VOIDmode here for labels */
6588
6589 /* For specific intrinsics with an immediate operand, e.g.,
6590 si_ai(), we sometimes need to convert the scalar argument to a
6591 vector argument by splatting the scalar. */
6592 if (VECTOR_MODE_P (mode)
6593 && (GET_CODE (ops[i]) == CONST_INT
6594 || GET_MODE_CLASS (GET_MODE (ops[i])) == MODE_INT
6595 || GET_MODE_CLASS (GET_MODE (ops[i])) == MODE_FLOAT))
6596 {
6597 if (GET_CODE (ops[i]) == CONST_INT)
6598 ops[i] = spu_const (mode, INTVAL (ops[i]));
6599 else
6600 {
6601 rtx reg = gen_reg_rtx (mode);
6602 enum machine_mode imode = GET_MODE_INNER (mode);
6603 if (!spu_nonmem_operand (ops[i], GET_MODE (ops[i])))
6604 ops[i] = force_reg (GET_MODE (ops[i]), ops[i]);
6605 if (imode != GET_MODE (ops[i]))
6606 ops[i] = convert_to_mode (imode, ops[i],
6607 TYPE_UNSIGNED (spu_builtin_types
6608 [d->parm[i]]));
6609 emit_insn (gen_spu_splats (reg, ops[i]));
6610 ops[i] = reg;
6611 }
6612 }
6613
6614 spu_check_builtin_parm (d, ops[i], d->parm[p]);
6615
6616 if (!(*insn_data[icode].operand[i].predicate) (ops[i], mode))
6617 ops[i] = spu_force_reg (mode, ops[i]);
6618 }
6619
6620 switch (n_operands)
6621 {
6622 case 0:
6623 pat = GEN_FCN (icode) (0);
6624 break;
6625 case 1:
6626 pat = GEN_FCN (icode) (ops[0]);
6627 break;
6628 case 2:
6629 pat = GEN_FCN (icode) (ops[0], ops[1]);
6630 break;
6631 case 3:
6632 pat = GEN_FCN (icode) (ops[0], ops[1], ops[2]);
6633 break;
6634 case 4:
6635 pat = GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3]);
6636 break;
6637 case 5:
6638 pat = GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3], ops[4]);
6639 break;
6640 case 6:
6641 pat = GEN_FCN (icode) (ops[0], ops[1], ops[2], ops[3], ops[4], ops[5]);
6642 break;
6643 default:
6644 abort ();
6645 }
6646
6647 if (!pat)
6648 abort ();
6649
6650 if (d->type == B_CALL || d->type == B_BISLED)
6651 emit_call_insn (pat);
6652 else if (d->type == B_JUMP)
6653 {
6654 emit_jump_insn (pat);
6655 emit_barrier ();
6656 }
6657 else
6658 emit_insn (pat);
6659
6660 return_type = spu_builtin_types[d->parm[0]];
6661 if (d->parm[0] != SPU_BTI_VOID
6662 && GET_MODE (target) != TYPE_MODE (return_type))
6663 {
6664 /* target is the return value. It should always be the mode of
6665 the builtin function prototype. */
6666 target = spu_force_reg (TYPE_MODE (return_type), target);
6667 }
6668
6669 return target;
6670 }
6671
6672 rtx
6673 spu_expand_builtin (tree exp,
6674 rtx target,
6675 rtx subtarget ATTRIBUTE_UNUSED,
6676 enum machine_mode mode ATTRIBUTE_UNUSED,
6677 int ignore ATTRIBUTE_UNUSED)
6678 {
6679 tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
6680 unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
6681 struct spu_builtin_description *d;
6682
6683 if (fcode < NUM_SPU_BUILTINS)
6684 {
6685 d = &spu_builtins[fcode];
6686
6687 return spu_expand_builtin_1 (d, exp, target);
6688 }
6689 abort ();
6690 }
6691
6692 /* Implement targetm.vectorize.builtin_mul_widen_even. */
6693 static tree
6694 spu_builtin_mul_widen_even (tree type)
6695 {
6696 switch (TYPE_MODE (type))
6697 {
6698 case V8HImode:
6699 if (TYPE_UNSIGNED (type))
6700 return spu_builtin_decls[SPU_MULE_0];
6701 else
6702 return spu_builtin_decls[SPU_MULE_1];
6703 break;
6704 default:
6705 return NULL_TREE;
6706 }
6707 }
6708
6709 /* Implement targetm.vectorize.builtin_mul_widen_odd. */
6710 static tree
6711 spu_builtin_mul_widen_odd (tree type)
6712 {
6713 switch (TYPE_MODE (type))
6714 {
6715 case V8HImode:
6716 if (TYPE_UNSIGNED (type))
6717 return spu_builtin_decls[SPU_MULO_1];
6718 else
6719 return spu_builtin_decls[SPU_MULO_0];
6720 break;
6721 default:
6722 return NULL_TREE;
6723 }
6724 }
6725
6726 /* Implement targetm.vectorize.builtin_mask_for_load. */
6727 static tree
6728 spu_builtin_mask_for_load (void)
6729 {
6730 return spu_builtin_decls[SPU_MASK_FOR_LOAD];
6731 }
6732
6733 /* Implement targetm.vectorize.builtin_vectorization_cost. */
6734 static int
6735 spu_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
6736 tree vectype ATTRIBUTE_UNUSED,
6737 int misalign ATTRIBUTE_UNUSED)
6738 {
6739 switch (type_of_cost)
6740 {
6741 case scalar_stmt:
6742 case vector_stmt:
6743 case vector_load:
6744 case vector_store:
6745 case vec_to_scalar:
6746 case scalar_to_vec:
6747 case cond_branch_not_taken:
6748 case vec_perm:
6749 return 1;
6750
6751 case scalar_store:
6752 return 10;
6753
6754 case scalar_load:
6755 /* Load + rotate. */
6756 return 2;
6757
6758 case unaligned_load:
6759 return 2;
6760
6761 case cond_branch_taken:
6762 return 6;
6763
6764 default:
6765 gcc_unreachable ();
6766 }
6767 }
6768
6769 /* Return true iff, data reference of TYPE can reach vector alignment (16)
6770 after applying N number of iterations. This routine does not determine
6771 how may iterations are required to reach desired alignment. */
6772
6773 static bool
6774 spu_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
6775 {
6776 if (is_packed)
6777 return false;
6778
6779 /* All other types are naturally aligned. */
6780 return true;
6781 }
6782
6783 /* Implement targetm.vectorize.builtin_vec_perm. */
6784 tree
6785 spu_builtin_vec_perm (tree type, tree *mask_element_type)
6786 {
6787 *mask_element_type = unsigned_char_type_node;
6788
6789 switch (TYPE_MODE (type))
6790 {
6791 case V16QImode:
6792 if (TYPE_UNSIGNED (type))
6793 return spu_builtin_decls[SPU_SHUFFLE_0];
6794 else
6795 return spu_builtin_decls[SPU_SHUFFLE_1];
6796
6797 case V8HImode:
6798 if (TYPE_UNSIGNED (type))
6799 return spu_builtin_decls[SPU_SHUFFLE_2];
6800 else
6801 return spu_builtin_decls[SPU_SHUFFLE_3];
6802
6803 case V4SImode:
6804 if (TYPE_UNSIGNED (type))
6805 return spu_builtin_decls[SPU_SHUFFLE_4];
6806 else
6807 return spu_builtin_decls[SPU_SHUFFLE_5];
6808
6809 case V2DImode:
6810 if (TYPE_UNSIGNED (type))
6811 return spu_builtin_decls[SPU_SHUFFLE_6];
6812 else
6813 return spu_builtin_decls[SPU_SHUFFLE_7];
6814
6815 case V4SFmode:
6816 return spu_builtin_decls[SPU_SHUFFLE_8];
6817
6818 case V2DFmode:
6819 return spu_builtin_decls[SPU_SHUFFLE_9];
6820
6821 default:
6822 return NULL_TREE;
6823 }
6824 }
6825
6826 /* Return the appropriate mode for a named address pointer. */
6827 static enum machine_mode
6828 spu_addr_space_pointer_mode (addr_space_t addrspace)
6829 {
6830 switch (addrspace)
6831 {
6832 case ADDR_SPACE_GENERIC:
6833 return ptr_mode;
6834 case ADDR_SPACE_EA:
6835 return EAmode;
6836 default:
6837 gcc_unreachable ();
6838 }
6839 }
6840
6841 /* Return the appropriate mode for a named address address. */
6842 static enum machine_mode
6843 spu_addr_space_address_mode (addr_space_t addrspace)
6844 {
6845 switch (addrspace)
6846 {
6847 case ADDR_SPACE_GENERIC:
6848 return Pmode;
6849 case ADDR_SPACE_EA:
6850 return EAmode;
6851 default:
6852 gcc_unreachable ();
6853 }
6854 }
6855
6856 /* Determine if one named address space is a subset of another. */
6857
6858 static bool
6859 spu_addr_space_subset_p (addr_space_t subset, addr_space_t superset)
6860 {
6861 gcc_assert (subset == ADDR_SPACE_GENERIC || subset == ADDR_SPACE_EA);
6862 gcc_assert (superset == ADDR_SPACE_GENERIC || superset == ADDR_SPACE_EA);
6863
6864 if (subset == superset)
6865 return true;
6866
6867 /* If we have -mno-address-space-conversion, treat __ea and generic as not
6868 being subsets but instead as disjoint address spaces. */
6869 else if (!TARGET_ADDRESS_SPACE_CONVERSION)
6870 return false;
6871
6872 else
6873 return (subset == ADDR_SPACE_GENERIC && superset == ADDR_SPACE_EA);
6874 }
6875
6876 /* Convert from one address space to another. */
6877 static rtx
6878 spu_addr_space_convert (rtx op, tree from_type, tree to_type)
6879 {
6880 addr_space_t from_as = TYPE_ADDR_SPACE (TREE_TYPE (from_type));
6881 addr_space_t to_as = TYPE_ADDR_SPACE (TREE_TYPE (to_type));
6882
6883 gcc_assert (from_as == ADDR_SPACE_GENERIC || from_as == ADDR_SPACE_EA);
6884 gcc_assert (to_as == ADDR_SPACE_GENERIC || to_as == ADDR_SPACE_EA);
6885
6886 if (to_as == ADDR_SPACE_GENERIC && from_as == ADDR_SPACE_EA)
6887 {
6888 rtx result, ls;
6889
6890 ls = gen_const_mem (DImode,
6891 gen_rtx_SYMBOL_REF (Pmode, "__ea_local_store"));
6892 set_mem_align (ls, 128);
6893
6894 result = gen_reg_rtx (Pmode);
6895 ls = force_reg (Pmode, convert_modes (Pmode, DImode, ls, 1));
6896 op = force_reg (Pmode, convert_modes (Pmode, EAmode, op, 1));
6897 ls = emit_conditional_move (ls, NE, op, const0_rtx, Pmode,
6898 ls, const0_rtx, Pmode, 1);
6899
6900 emit_insn (gen_subsi3 (result, op, ls));
6901
6902 return result;
6903 }
6904
6905 else if (to_as == ADDR_SPACE_EA && from_as == ADDR_SPACE_GENERIC)
6906 {
6907 rtx result, ls;
6908
6909 ls = gen_const_mem (DImode,
6910 gen_rtx_SYMBOL_REF (Pmode, "__ea_local_store"));
6911 set_mem_align (ls, 128);
6912
6913 result = gen_reg_rtx (EAmode);
6914 ls = force_reg (EAmode, convert_modes (EAmode, DImode, ls, 1));
6915 op = force_reg (Pmode, op);
6916 ls = emit_conditional_move (ls, NE, op, const0_rtx, Pmode,
6917 ls, const0_rtx, EAmode, 1);
6918 op = force_reg (EAmode, convert_modes (EAmode, Pmode, op, 1));
6919
6920 if (EAmode == SImode)
6921 emit_insn (gen_addsi3 (result, op, ls));
6922 else
6923 emit_insn (gen_adddi3 (result, op, ls));
6924
6925 return result;
6926 }
6927
6928 else
6929 gcc_unreachable ();
6930 }
6931
6932
6933 /* Count the total number of instructions in each pipe and return the
6934 maximum, which is used as the Minimum Iteration Interval (MII)
6935 in the modulo scheduler. get_pipe() will return -2, -1, 0, or 1.
6936 -2 are instructions that can go in pipe0 or pipe1. */
6937 static int
6938 spu_sms_res_mii (struct ddg *g)
6939 {
6940 int i;
6941 unsigned t[4] = {0, 0, 0, 0};
6942
6943 for (i = 0; i < g->num_nodes; i++)
6944 {
6945 rtx insn = g->nodes[i].insn;
6946 int p = get_pipe (insn) + 2;
6947
6948 assert (p >= 0);
6949 assert (p < 4);
6950
6951 t[p]++;
6952 if (dump_file && INSN_P (insn))
6953 fprintf (dump_file, "i%d %s %d %d\n",
6954 INSN_UID (insn),
6955 insn_data[INSN_CODE(insn)].name,
6956 p, t[p]);
6957 }
6958 if (dump_file)
6959 fprintf (dump_file, "%d %d %d %d\n", t[0], t[1], t[2], t[3]);
6960
6961 return MAX ((t[0] + t[2] + t[3] + 1) / 2, MAX (t[2], t[3]));
6962 }
6963
6964
6965 void
6966 spu_init_expanders (void)
6967 {
6968 if (cfun)
6969 {
6970 rtx r0, r1;
6971 /* HARD_FRAME_REGISTER is only 128 bit aligned when
6972 frame_pointer_needed is true. We don't know that until we're
6973 expanding the prologue. */
6974 REGNO_POINTER_ALIGN (HARD_FRAME_POINTER_REGNUM) = 8;
6975
6976 /* A number of passes use LAST_VIRTUAL_REGISTER+1 and
6977 LAST_VIRTUAL_REGISTER+2 to test the back-end. We want them
6978 to be treated as aligned, so generate them here. */
6979 r0 = gen_reg_rtx (SImode);
6980 r1 = gen_reg_rtx (SImode);
6981 mark_reg_pointer (r0, 128);
6982 mark_reg_pointer (r1, 128);
6983 gcc_assert (REGNO (r0) == LAST_VIRTUAL_REGISTER + 1
6984 && REGNO (r1) == LAST_VIRTUAL_REGISTER + 2);
6985 }
6986 }
6987
6988 static enum machine_mode
6989 spu_libgcc_cmp_return_mode (void)
6990 {
6991
6992 /* For SPU word mode is TI mode so it is better to use SImode
6993 for compare returns. */
6994 return SImode;
6995 }
6996
6997 static enum machine_mode
6998 spu_libgcc_shift_count_mode (void)
6999 {
7000 /* For SPU word mode is TI mode so it is better to use SImode
7001 for shift counts. */
7002 return SImode;
7003 }
7004
7005 /* An early place to adjust some flags after GCC has finished processing
7006 * them. */
7007 static void
7008 asm_file_start (void)
7009 {
7010 /* Variable tracking should be run after all optimizations which
7011 change order of insns. It also needs a valid CFG. */
7012 spu_flag_var_tracking = flag_var_tracking;
7013 flag_var_tracking = 0;
7014
7015 default_file_start ();
7016 }
7017
7018 /* Implement targetm.section_type_flags. */
7019 static unsigned int
7020 spu_section_type_flags (tree decl, const char *name, int reloc)
7021 {
7022 /* .toe needs to have type @nobits. */
7023 if (strcmp (name, ".toe") == 0)
7024 return SECTION_BSS;
7025 /* Don't load _ea into the current address space. */
7026 if (strcmp (name, "._ea") == 0)
7027 return SECTION_WRITE | SECTION_DEBUG;
7028 return default_section_type_flags (decl, name, reloc);
7029 }
7030
7031 /* Implement targetm.select_section. */
7032 static section *
7033 spu_select_section (tree decl, int reloc, unsigned HOST_WIDE_INT align)
7034 {
7035 /* Variables and constants defined in the __ea address space
7036 go into a special section named "._ea". */
7037 if (TREE_TYPE (decl) != error_mark_node
7038 && TYPE_ADDR_SPACE (TREE_TYPE (decl)) == ADDR_SPACE_EA)
7039 {
7040 /* We might get called with string constants, but get_named_section
7041 doesn't like them as they are not DECLs. Also, we need to set
7042 flags in that case. */
7043 if (!DECL_P (decl))
7044 return get_section ("._ea", SECTION_WRITE | SECTION_DEBUG, NULL);
7045
7046 return get_named_section (decl, "._ea", reloc);
7047 }
7048
7049 return default_elf_select_section (decl, reloc, align);
7050 }
7051
7052 /* Implement targetm.unique_section. */
7053 static void
7054 spu_unique_section (tree decl, int reloc)
7055 {
7056 /* We don't support unique section names in the __ea address
7057 space for now. */
7058 if (TREE_TYPE (decl) != error_mark_node
7059 && TYPE_ADDR_SPACE (TREE_TYPE (decl)) != 0)
7060 return;
7061
7062 default_unique_section (decl, reloc);
7063 }
7064
7065 /* Generate a constant or register which contains 2^SCALE. We assume
7066 the result is valid for MODE. Currently, MODE must be V4SFmode and
7067 SCALE must be SImode. */
7068 rtx
7069 spu_gen_exp2 (enum machine_mode mode, rtx scale)
7070 {
7071 gcc_assert (mode == V4SFmode);
7072 gcc_assert (GET_MODE (scale) == SImode || GET_CODE (scale) == CONST_INT);
7073 if (GET_CODE (scale) != CONST_INT)
7074 {
7075 /* unsigned int exp = (127 + scale) << 23;
7076 __vector float m = (__vector float) spu_splats (exp); */
7077 rtx reg = force_reg (SImode, scale);
7078 rtx exp = gen_reg_rtx (SImode);
7079 rtx mul = gen_reg_rtx (mode);
7080 emit_insn (gen_addsi3 (exp, reg, GEN_INT (127)));
7081 emit_insn (gen_ashlsi3 (exp, exp, GEN_INT (23)));
7082 emit_insn (gen_spu_splats (mul, gen_rtx_SUBREG (GET_MODE_INNER (mode), exp, 0)));
7083 return mul;
7084 }
7085 else
7086 {
7087 HOST_WIDE_INT exp = 127 + INTVAL (scale);
7088 unsigned char arr[16];
7089 arr[0] = arr[4] = arr[8] = arr[12] = exp >> 1;
7090 arr[1] = arr[5] = arr[9] = arr[13] = exp << 7;
7091 arr[2] = arr[6] = arr[10] = arr[14] = 0;
7092 arr[3] = arr[7] = arr[11] = arr[15] = 0;
7093 return array_to_constant (mode, arr);
7094 }
7095 }
7096
7097 /* After reload, just change the convert into a move instruction
7098 or a dead instruction. */
7099 void
7100 spu_split_convert (rtx ops[])
7101 {
7102 if (REGNO (ops[0]) == REGNO (ops[1]))
7103 emit_note (NOTE_INSN_DELETED);
7104 else
7105 {
7106 /* Use TImode always as this might help hard reg copyprop. */
7107 rtx op0 = gen_rtx_REG (TImode, REGNO (ops[0]));
7108 rtx op1 = gen_rtx_REG (TImode, REGNO (ops[1]));
7109 emit_insn (gen_move_insn (op0, op1));
7110 }
7111 }
7112
7113 void
7114 spu_function_profiler (FILE * file, int labelno)
7115 {
7116 fprintf (file, "# profile\n");
7117 fprintf (file, "brsl $75, _mcount\n");
7118 }
7119
7120 #include "gt-spu.h"
Mirror of the offical gcc git repository hosted at gcc.gnu.org