OSDN Git Service

PR c/448
[pf3gnuchains/gcc-fork.git] / gcc / config / spu / spu.h
1 /* Copyright (C) 2006, 2007, 2008, 2009 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 \f
18 /* Run-time Target */
19 #define TARGET_CPU_CPP_BUILTINS()       spu_cpu_cpp_builtins(pfile)
20
21 #define TARGET_VERSION fprintf (stderr, " (spu %s)", __DATE__);
22
23 #define OVERRIDE_OPTIONS spu_override_options()
24 #define C_COMMON_OVERRIDE_OPTIONS spu_c_common_override_options()
25
26 #define OPTIMIZATION_OPTIONS(level,size) \
27           spu_optimization_options(level,size)
28
29 #define INIT_EXPANDERS spu_init_expanders()
30
31 extern int target_flags;
32 extern const char *spu_fixed_range_string;
33
34 /* Which processor to generate code or schedule for.  */
35 enum processor_type
36 {
37   PROCESSOR_CELL,
38   PROCESSOR_CELLEDP
39 };
40
41 extern GTY(()) int spu_arch;
42 extern GTY(()) int spu_tune;
43
44 /* Support for a compile-time default architecture and tuning.  The rules are:
45    --with-arch is ignored if -march is specified.
46    --with-tune is ignored if -mtune is specified.  */
47 #define OPTION_DEFAULT_SPECS \
48   {"arch", "%{!march=*:-march=%(VALUE)}" }, \
49   {"tune", "%{!mtune=*:-mtune=%(VALUE)}" }
50
51 /* Default target_flags if no switches specified.  */
52 #ifndef TARGET_DEFAULT
53 #define TARGET_DEFAULT (MASK_ERROR_RELOC | MASK_SAFE_DMA | MASK_BRANCH_HINTS \
54                         | MASK_SAFE_HINTS)
55 #endif
56
57 \f
58 /* Storage Layout */
59
60 #define BITS_BIG_ENDIAN 1
61
62 #define BYTES_BIG_ENDIAN 1
63
64 #define WORDS_BIG_ENDIAN 1
65
66 #define BITS_PER_UNIT 8
67
68 /* GCC uses word_mode in many places, assuming that it is the fastest
69    integer mode.  That is not the case for SPU though.  We can't use
70    32 here because (of some reason I can't remember.) */
71 #define BITS_PER_WORD 128
72
73 #define UNITS_PER_WORD (BITS_PER_WORD/BITS_PER_UNIT)
74
75 /* We never actually change UNITS_PER_WORD, but defining this causes
76    libgcc to use some different sizes of types when compiling. */
77 #define MIN_UNITS_PER_WORD 4
78
79 #define POINTER_SIZE 32
80
81 #define PARM_BOUNDARY 128
82
83 #define STACK_BOUNDARY 128
84
85 /* We want it 8-byte aligned so we can properly use dual-issue
86    instructions, which can only happen on an 8-byte aligned address. */
87 #define FUNCTION_BOUNDARY 64
88
89 /* We would like to allow a larger alignment for data objects (for DMA)
90    but the aligned attribute is limited by BIGGEST_ALIGNMENT.  We don't
91    define BIGGEST_ALIGNMENT as larger because it is used in other places
92    and would end up wasting space.  (Is this still true?)  */
93 #define BIGGEST_ALIGNMENT 128
94
95 #define MINIMUM_ATOMIC_ALIGNMENT 128
96
97 /* Make all static objects 16-byte aligned.  This allows us to assume
98    they are also padded to 16-bytes, which means we can use a single
99    load or store instruction to access them.  Do the same for objects
100    on the stack.  (Except a bug (?) allows some stack objects to be
101    unaligned.)  */
102 #define DATA_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
103 #define CONSTANT_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
104 #define LOCAL_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
105
106 #define EMPTY_FIELD_BOUNDARY 32
107
108 #define STRICT_ALIGNMENT 1
109
110 /* symbol_ref's of functions are not aligned to 16 byte boundary. */
111 #define ALIGNED_SYMBOL_REF_P(X) \
112         (GET_CODE (X) == SYMBOL_REF \
113           && (SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_ALIGN1) == 0 \
114           && (! SYMBOL_REF_FUNCTION_P (X) \
115               || align_functions >= 16))
116
117 #define PCC_BITFIELD_TYPE_MATTERS 1
118
119 #define MAX_FIXED_MODE_SIZE 128
120
121 #define STACK_SAVEAREA_MODE(save_level) \
122   (save_level == SAVE_FUNCTION ? VOIDmode \
123     : save_level == SAVE_NONLOCAL ? SImode \
124       : Pmode)
125
126 #define STACK_SIZE_MODE SImode
127
128 \f
129 /* Type Layout */
130
131 #define INT_TYPE_SIZE 32
132
133 #define LONG_TYPE_SIZE 32
134
135 #define LONG_LONG_TYPE_SIZE 64
136
137 #define FLOAT_TYPE_SIZE 32
138
139 #define DOUBLE_TYPE_SIZE 64
140
141 #define LONG_DOUBLE_TYPE_SIZE 64
142
143 #define DEFAULT_SIGNED_CHAR 0
144
145 #define STDINT_LONG32 0
146
147 \f
148 /* Register Basics */
149
150 /* 128-130 are special registers that never appear in assembly code. */
151 #define FIRST_PSEUDO_REGISTER 131
152
153 #define FIXED_REGISTERS {                           \
154     1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
155     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
156     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
157     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
158     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
159     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
160     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
161     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
162     1, 1, 1 \
163 }
164
165 #define CALL_USED_REGISTERS {                       \
166     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
167     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
168     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
169     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
170     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
171     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
172     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
173     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
174     1, 1, 1 \
175 }
176
177 #define CONDITIONAL_REGISTER_USAGE \
178         spu_conditional_register_usage()
179
180 \f
181 /* Values in Registers */
182
183 #define HARD_REGNO_NREGS(REGNO, MODE)   \
184     ((GET_MODE_BITSIZE(MODE)+MAX_FIXED_MODE_SIZE-1)/MAX_FIXED_MODE_SIZE)
185
186 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
187
188 #define MODES_TIEABLE_P(MODE1, MODE2) \
189   (GET_MODE_BITSIZE (MODE1) <= MAX_FIXED_MODE_SIZE \
190    && GET_MODE_BITSIZE (MODE2) <= MAX_FIXED_MODE_SIZE)
191
192 \f
193 /* Register Classes */
194
195 enum reg_class { 
196    NO_REGS, 
197    GENERAL_REGS,
198    ALL_REGS,
199    LIM_REG_CLASSES 
200 };
201
202 /* SPU is simple, it really only has one class of registers.  */
203 #define IRA_COVER_CLASSES { GENERAL_REGS, LIM_REG_CLASSES }
204
205 #define N_REG_CLASSES (int) LIM_REG_CLASSES
206
207 #define REG_CLASS_NAMES \
208 {  "NO_REGS", \
209    "GENERAL_REGS", \
210    "ALL_REGS" \
211 }
212
213 #define REG_CLASS_CONTENTS { \
214     {0, 0, 0, 0, 0}, /* no regs */ \
215     {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x3}, /* general regs */ \
216     {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x3}} /* all regs */
217
218 #define REGNO_REG_CLASS(REGNO) (GENERAL_REGS)
219
220 #define BASE_REG_CLASS GENERAL_REGS
221
222 #define INDEX_REG_CLASS GENERAL_REGS
223
224 #define REGNO_OK_FOR_BASE_P(regno) \
225    ((regno) < FIRST_PSEUDO_REGISTER || (regno > LAST_VIRTUAL_REGISTER && reg_renumber[regno] >= 0))
226
227 #define REGNO_OK_FOR_INDEX_P(regno)  \
228    ((regno) < FIRST_PSEUDO_REGISTER || (regno > LAST_VIRTUAL_REGISTER && reg_renumber[regno] >= 0))
229
230 #define INT_REG_OK_FOR_INDEX_P(X,STRICT) \
231         ((!(STRICT) || REGNO_OK_FOR_INDEX_P (REGNO (X))))
232 #define INT_REG_OK_FOR_BASE_P(X,STRICT) \
233         ((!(STRICT) || REGNO_OK_FOR_BASE_P (REGNO (X))))
234
235 #define PREFERRED_RELOAD_CLASS(X,CLASS)  (CLASS)
236
237 #define CLASS_MAX_NREGS(CLASS, MODE)    \
238         ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
239
240 /* GCC assumes that modes are in the lowpart of a register, which is
241    only true for SPU. */
242 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
243         ((GET_MODE_SIZE (FROM) > 4 || GET_MODE_SIZE (TO) > 4) \
244          && (GET_MODE_SIZE (FROM) < 16 || GET_MODE_SIZE (TO) < 16) \
245          && GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO))
246
247 #define REGISTER_TARGET_PRAGMAS() do {                                  \
248 targetm.resolve_overloaded_builtin = spu_resolve_overloaded_builtin;    \
249 }while (0);
250
251 \f
252 /* Frame Layout */
253
254 #define STACK_GROWS_DOWNWARD
255
256 #define FRAME_GROWS_DOWNWARD 1
257
258 #define STARTING_FRAME_OFFSET (0)
259
260 #define STACK_POINTER_OFFSET 32
261
262 #define FIRST_PARM_OFFSET(FNDECL) (0)
263
264 #define DYNAMIC_CHAIN_ADDRESS(FP) plus_constant ((FP), -16)
265
266 #define RETURN_ADDR_RTX(COUNT,FP) (spu_return_addr (COUNT, FP))
267
268 /* Should this be defined?  Would it simplify our implementation. */
269 /* #define RETURN_ADDR_IN_PREVIOUS_FRAME */
270
271 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG(Pmode, LINK_REGISTER_REGNUM)
272
273 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (LINK_REGISTER_REGNUM)
274
275 #define ARG_POINTER_CFA_OFFSET(FNDECL) (-STACK_POINTER_OFFSET)
276
277 \f
278 /* Stack Checking */
279
280 /* We store the Available Stack Size in the second slot of the stack
281    register.   We emit stack checking code during the prologue.  */
282 #define STACK_CHECK_BUILTIN 1
283
284 \f
285 /* Frame Registers, and other registers */
286
287 #define STACK_POINTER_REGNUM 1
288
289 /* Will be eliminated. */
290 #define FRAME_POINTER_REGNUM 128
291
292 /* This is not specified in any ABI, so could be set to anything. */
293 #define HARD_FRAME_POINTER_REGNUM 127
294
295 /* Will be eliminated. */
296 #define ARG_POINTER_REGNUM 129
297
298 #define STATIC_CHAIN_REGNUM 2
299
300 #define LINK_REGISTER_REGNUM 0
301
302 /* Used to keep track of instructions that have clobbered the hint
303  * buffer.  Users can also specify it in inline asm. */
304 #define HBR_REGNUM 130
305
306 #define MAX_REGISTER_ARGS    72
307 #define FIRST_ARG_REGNUM     3
308 #define LAST_ARG_REGNUM      (FIRST_ARG_REGNUM + MAX_REGISTER_ARGS - 1)
309
310 #define MAX_REGISTER_RETURN  72
311 #define FIRST_RETURN_REGNUM  3
312 #define LAST_RETURN_REGNUM   (FIRST_RETURN_REGNUM + MAX_REGISTER_RETURN - 1)
313
314 \f
315 /* Elimination */
316
317 #define FRAME_POINTER_REQUIRED 0
318
319 #define ELIMINABLE_REGS  \
320   {{ARG_POINTER_REGNUM,  STACK_POINTER_REGNUM},                         \
321   {ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM},                    \
322   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},                         \
323   {FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
324
325 #define CAN_ELIMINATE(FROM,TO) 1 
326
327 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
328   ((OFFSET) = spu_initial_elimination_offset((FROM),(TO)))
329
330 \f
331 /* Stack Arguments */
332
333 #define ACCUMULATE_OUTGOING_ARGS 1
334
335 #define REG_PARM_STACK_SPACE(FNDECL) 0
336
337 #define OUTGOING_REG_PARM_STACK_SPACE(FNTYPE) 1
338
339 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) (0)
340
341 \f
342 /* Register Arguments */
343
344 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
345         (spu_function_arg((CUM),(MODE),(TYPE),(NAMED)))
346
347 #define CUMULATIVE_ARGS int
348
349 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
350                 ((CUM) = 0)
351
352 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
353         ((CUM) += \
354          (TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST ? 1 \
355          : (MODE) == BLKmode ? ((int_size_in_bytes(TYPE)+15) / 16) \
356          : (MODE) == VOIDmode ? 1 \
357          : HARD_REGNO_NREGS(CUM,MODE))
358
359
360 /* The SPU ABI wants 32/64-bit types at offset 0 in the quad-word on the
361    stack.  8/16-bit types should be at offsets 3/2 respectively.  */
362 #define FUNCTION_ARG_OFFSET(MODE, TYPE)                                 \
363 (((TYPE) && INTEGRAL_TYPE_P (TYPE) && GET_MODE_SIZE (MODE) < 4)         \
364  ? (4 - GET_MODE_SIZE (MODE))                                           \
365  : 0)
366
367 #define FUNCTION_ARG_PADDING(MODE,TYPE) upward
368
369 #define PAD_VARARGS_DOWN 0
370
371 #define FUNCTION_ARG_REGNO_P(N) ((N) >= (FIRST_ARG_REGNUM) && (N) <= (LAST_ARG_REGNUM))
372 \f
373 /* Scalar Return */
374
375 #define FUNCTION_VALUE(VALTYPE, FUNC) \
376         (spu_function_value((VALTYPE),(FUNC)))
377
378 #define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, FIRST_RETURN_REGNUM)
379
380 #define FUNCTION_VALUE_REGNO_P(N) ((N) >= (FIRST_RETURN_REGNUM) && (N) <= (LAST_RETURN_REGNUM))
381
382 \f
383 /* Machine-specific symbol_ref flags.  */
384 #define SYMBOL_FLAG_ALIGN1      (SYMBOL_FLAG_MACH_DEP << 0)
385 \f
386 /* Aggregate Return */
387
388 #define DEFAULT_PCC_STRUCT_RETURN 0
389
390 \f
391 /* Function Entry */
392
393 #define EXIT_IGNORE_STACK 0
394
395 #define EPILOGUE_USES(REGNO) ((REGNO)==1 ? 1 : 0)
396
397 \f
398 /* Profiling */
399
400 /* Nothing, for now. */
401 #define FUNCTION_PROFILER(FILE, LABELNO)  \
402    fprintf (FILE, "\t\n")
403
404 \f
405 /* Trampolines */
406
407 #define TRAMPOLINE_SIZE (TARGET_LARGE_MEM ? 20 : 16)
408
409 #define TRAMPOLINE_ALIGNMENT 128
410
411 #define INITIALIZE_TRAMPOLINE(TRAMP,FNADDR,CXT) \
412           spu_initialize_trampoline(TRAMP,FNADDR,CXT)
413
414 \f
415 /* Addressing Modes */
416
417 #define CONSTANT_ADDRESS_P(X)   spu_constant_address_p(X)
418
419 #define MAX_REGS_PER_ADDRESS 2
420
421 #ifdef REG_OK_STRICT
422 # define REG_OK_STRICT_FLAG 1
423 #else
424 # define REG_OK_STRICT_FLAG 0
425 #endif
426
427 #define GO_IF_LEGITIMATE_ADDRESS(MODE, X, ADDR)                 \
428     { if (spu_legitimate_address (MODE, X, REG_OK_STRICT_FLAG)) \
429         goto ADDR;                                              \
430     }
431
432 #define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \
433   {  rtx result = spu_legitimize_address (X, OLDX, MODE);       \
434      if (result != NULL_RTX)                                    \
435        {                                                        \
436          (X) = result;                                          \
437          goto WIN;                                              \
438        }                                                        \
439   }
440
441 #define GO_IF_MODE_DEPENDENT_ADDRESS(ADDR,LABEL)
442
443 #define LEGITIMATE_CONSTANT_P(X) spu_legitimate_constant_p(X)
444
445 \f
446 /* Costs */
447
448 #define BRANCH_COST(speed_p, predictable_p) spu_branch_cost
449
450 #define SLOW_BYTE_ACCESS 0
451
452 #define MOVE_RATIO(speed) 32
453
454 #define NO_FUNCTION_CSE
455
456 \f
457 /* Sections */
458
459 #define TEXT_SECTION_ASM_OP ".text"
460
461 #define DATA_SECTION_ASM_OP ".data"
462
463 #define JUMP_TABLES_IN_TEXT_SECTION 1
464
465 \f
466 /* PIC */
467 #define PIC_OFFSET_TABLE_REGNUM 126
468
469 \f
470 /* File Framework */
471
472 #define ASM_APP_ON ""
473
474 #define ASM_APP_OFF ""
475
476 #define ASM_OUTPUT_SOURCE_FILENAME(STREAM, NAME) \
477   do {  fprintf (STREAM, "\t.file\t");                  \
478         output_quoted_string (STREAM, NAME);            \
479         fprintf (STREAM, "\n");                         \
480   } while (0)
481
482 \f
483 /* Uninitialized Data */
484 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
485 ( fputs (".comm ", (FILE)),                     \
486   assemble_name ((FILE), (NAME)),               \
487   fprintf ((FILE), ",%d\n", (ROUNDED)))
488
489 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
490 ( fputs (".lcomm ", (FILE)),                    \
491   assemble_name ((FILE), (NAME)),               \
492   fprintf ((FILE), ",%d\n", (ROUNDED)))
493
494 \f
495 /* Label Output */
496 #define ASM_OUTPUT_LABEL(FILE,NAME)     \
497   do { assemble_name (FILE, NAME); fputs (":\n", FILE); } while (0)
498
499 #define ASM_OUTPUT_LABELREF(FILE, NAME) \
500   asm_fprintf (FILE, "%U%s", default_strip_name_encoding (NAME))
501
502 \f
503 /* Instruction Output */
504 #define REGISTER_NAMES \
505 {"$lr", "$sp", "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", \
506  "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23", "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31", \
507  "$32", "$33", "$34", "$35", "$36", "$37", "$38", "$39", "$40", "$41", "$42", "$43", "$44", "$45", "$46", "$47", \
508  "$48", "$49", "$50", "$51", "$52", "$53", "$54", "$55", "$56", "$57", "$58", "$59", "$60", "$61", "$62", "$63", \
509  "$64", "$65", "$66", "$67", "$68", "$69", "$70", "$71", "$72", "$73", "$74", "$75", "$76", "$77", "$78", "$79", \
510  "$80", "$81", "$82", "$83", "$84", "$85", "$86", "$87", "$88", "$89", "$90", "$91", "$92", "$93", "$94", "$95", \
511  "$96", "$97", "$98", "$99", "$100", "$101", "$102", "$103", "$104", "$105", "$106", "$107", "$108", "$109", "$110", "$111", \
512  "$112", "$113", "$114", "$115", "$116", "$117", "$118", "$119", "$120", "$121", "$122", "$123", "$124", "$125", "$126", "$127", \
513  "$vfp", "$vap", "hbr" \
514 }
515
516 #define PRINT_OPERAND(FILE, X, CODE)  print_operand(FILE, X, CODE)
517
518 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
519  print_operand_address (FILE, ADDR)
520
521 #define LOCAL_LABEL_PREFIX "."
522
523 #define USER_LABEL_PREFIX ""
524
525 \f
526 /* Dispatch Tables */
527
528 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)  \
529   fprintf (FILE, "\t.word .L%d-.L%d\n", VALUE, REL)
530
531 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
532   fprintf (FILE, "\t.word .L%d\n", VALUE)
533
534 \f
535 /* Alignment Output */
536
537 #define ASM_OUTPUT_ALIGN(FILE,LOG)  \
538   do { if (LOG!=0) fprintf (FILE, "\t.align\t%d\n", (LOG)); } while (0)
539
540 \f
541 /* Model costs for the vectorizer.  */
542
543 /* Cost of conditional branch.  */
544 #ifndef TARG_COND_BRANCH_COST
545 #define TARG_COND_BRANCH_COST        6
546 #endif
547
548 /* Cost of any scalar operation, excluding load and store.  */
549 #ifndef TARG_SCALAR_STMT_COST
550 #define TARG_SCALAR_STMT_COST        1
551 #endif
552
553 /* Cost of scalar load. */
554 #undef TARG_SCALAR_LOAD_COST
555 #define TARG_SCALAR_LOAD_COST        2 /* load + rotate */
556
557 /* Cost of scalar store.  */
558 #undef TARG_SCALAR_STORE_COST
559 #define TARG_SCALAR_STORE_COST       10
560
561 /* Cost of any vector operation, excluding load, store,
562    or vector to scalar operation.  */
563 #undef TARG_VEC_STMT_COST
564 #define TARG_VEC_STMT_COST           1
565
566 /* Cost of vector to scalar operation.  */
567 #undef TARG_VEC_TO_SCALAR_COST
568 #define TARG_VEC_TO_SCALAR_COST      1
569
570 /* Cost of scalar to vector operation.  */
571 #undef TARG_SCALAR_TO_VEC_COST
572 #define TARG_SCALAR_TO_VEC_COST      1
573
574 /* Cost of aligned vector load.  */
575 #undef TARG_VEC_LOAD_COST
576 #define TARG_VEC_LOAD_COST           1
577
578 /* Cost of misaligned vector load.  */
579 #undef TARG_VEC_UNALIGNED_LOAD_COST
580 #define TARG_VEC_UNALIGNED_LOAD_COST 2
581
582 /* Cost of vector store.  */
583 #undef TARG_VEC_STORE_COST
584 #define TARG_VEC_STORE_COST          1
585
586 /* Cost of vector permutation.  */
587 #ifndef TARG_VEC_PERMUTE_COST
588 #define TARG_VEC_PERMUTE_COST        1 
589 #endif
590
591 \f
592 /* Misc */
593
594 #define CASE_VECTOR_MODE SImode
595
596 #define MOVE_MAX 16 
597
598 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) ((INPREC) <= 32 && (OUTPREC) <= (INPREC))
599
600 #define STORE_FLAG_VALUE -1
601
602 #define Pmode SImode
603
604 #define FUNCTION_MODE QImode
605
606 #define NO_IMPLICIT_EXTERN_C 1
607
608 #define HANDLE_PRAGMA_PACK_PUSH_POP 1
609
610 /* Canonicalize a comparison from one we don't have to one we do have.  */
611 #define CANONICALIZE_COMPARISON(CODE,OP0,OP1) \
612   do {                                                                    \
613     if (((CODE) == LE || (CODE) == LT || (CODE) == LEU || (CODE) == LTU)) \
614       {                                                                   \
615         rtx tem = (OP0);                                                  \
616         (OP0) = (OP1);                                                    \
617         (OP1) = tem;                                                      \
618         (CODE) = swap_condition (CODE);                                   \
619       }                                                                   \
620   } while (0)
621
622 /* These are set by the cmp patterns and used while expanding
623    conditional branches. */
624 extern GTY(()) rtx spu_compare_op0;
625 extern GTY(()) rtx spu_compare_op1;
626