OSDN Git Service

2007-02-21 Trevor Smigiel <trevor_smigiel@playstation.sony.com>
[pf3gnuchains/gcc-fork.git] / gcc / config / spu / spu.h
1 /* Copyright (C) 2006 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 2 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 this file; see the file COPYING.  If not, write to the Free
15    Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
16    02110-1301, USA.  */
17
18 \f
19 /* Run-time Target */
20 #define TARGET_CPU_CPP_BUILTINS()       spu_cpu_cpp_builtins(pfile)
21
22 #define TARGET_VERSION fprintf (stderr, " (spu %s)", __DATE__);
23
24 #define OVERRIDE_OPTIONS spu_override_options()
25 #define C_COMMON_OVERRIDE_OPTIONS spu_c_common_override_options()
26
27 #define OPTIMIZATION_OPTIONS(level,size) \
28           spu_optimization_options(level,size)
29
30 #define INIT_EXPANDERS spu_init_expanders()
31
32 extern int target_flags;
33 extern const char *spu_fixed_range_string;
34
35 /* Default target_flags if no switches specified.  */
36 #ifndef TARGET_DEFAULT
37 #define TARGET_DEFAULT (MASK_ERROR_RELOC | MASK_SAFE_DMA | MASK_BRANCH_HINTS)
38 #endif
39
40 \f
41 /* Storage Layout */
42
43 #define BITS_BIG_ENDIAN 1
44
45 #define BYTES_BIG_ENDIAN 1
46
47 #define WORDS_BIG_ENDIAN 1
48
49 #define BITS_PER_UNIT 8
50
51 /* GCC uses word_mode in many places, assuming that it is the fastest
52    integer mode.  That is not the case for SPU though.  We can't use
53    32 here because (of some reason I can't remember.) */
54 #define BITS_PER_WORD 128
55
56 #define UNITS_PER_WORD (BITS_PER_WORD/BITS_PER_UNIT)
57
58 /* We never actually change UNITS_PER_WORD, but defining this causes
59    libgcc to use some different sizes of types when compiling. */
60 #define MIN_UNITS_PER_WORD 4
61
62 #define POINTER_SIZE 32
63
64 #define PARM_BOUNDARY 128
65
66 #define STACK_BOUNDARY 128
67
68 /* We want it 8-byte aligned so we can properly use dual-issue
69    instructions, which can only happen on an 8-byte aligned address. */
70 #define FUNCTION_BOUNDARY 64
71
72 /* We would like to allow a larger alignment for data objects (for DMA)
73    but the aligned attribute is limited by BIGGEST_ALIGNMENT.  We don't
74    define BIGGEST_ALIGNMENT as larger because it is used in other places
75    and would end up wasting space.  (Is this still true?)  */
76 #define BIGGEST_ALIGNMENT 128
77
78 #define MINIMUM_ATOMIC_ALIGNMENT 128
79
80 /* Make all static objects 16-byte aligned.  This allows us to assume
81    they are also padded to 16-bytes, which means we can use a single
82    load or store instruction to access them.  Do the same for objects
83    on the stack.  (Except a bug (?) allows some stack objects to be
84    unaligned.)  */
85 #define DATA_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
86 #define CONSTANT_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
87 #define LOCAL_ALIGNMENT(TYPE,ALIGN) ((ALIGN) > 128 ? (ALIGN) : 128)
88
89 #define EMPTY_FIELD_BOUNDARY 32
90
91 #define STRICT_ALIGNMENT 1
92
93 /* symbol_ref's of functions are not aligned to 16 byte boundary. */
94 #define ALIGNED_SYMBOL_REF_P(X) \
95         (GET_CODE (X) == SYMBOL_REF \
96           && (SYMBOL_REF_FLAGS (X) & SYMBOL_FLAG_ALIGN1) == 0 \
97           && (! SYMBOL_REF_FUNCTION_P (X) \
98               || align_functions >= 16))
99
100 #define PCC_BITFIELD_TYPE_MATTERS 1
101
102 #define MAX_FIXED_MODE_SIZE 128
103
104 #define STACK_SAVEAREA_MODE(save_level) \
105   (save_level == SAVE_FUNCTION ? VOIDmode \
106     : save_level == SAVE_NONLOCAL ? SImode \
107       : Pmode)
108
109 #define STACK_SIZE_MODE SImode
110
111 /* #define TARGET_FLOAT_FORMAT          SPU_FLOAT_FORMAT */
112
113 #ifndef MODE_HAS_NANS
114 #define MODE_HAS_NANS(MODE)                                     \
115   (FLOAT_MODE_P (MODE)                                          \
116    && MODE != SFmode                                            \
117    && !LARGEST_EXPONENT_IS_NORMAL (GET_MODE_BITSIZE (MODE)))
118 #endif
119                                                                               
120 #ifndef MODE_HAS_INFINITIES
121 #define MODE_HAS_INFINITIES(MODE)                               \
122   (FLOAT_MODE_P (MODE)                                          \
123    && MODE != SFmode                                            \
124    && !LARGEST_EXPONENT_IS_NORMAL (GET_MODE_BITSIZE (MODE)))
125 #endif
126                                                                               
127 #ifndef MODE_HAS_SIGN_DEPENDENT_ROUNDING
128 #define MODE_HAS_SIGN_DEPENDENT_ROUNDING(MODE)                  \
129   (FLOAT_MODE_P (MODE)                                          \
130     && MODE != SFmode                                           \
131    && !ROUND_TOWARDS_ZERO)
132 #endif
133
134 #define ROUND_TOWARDS_ZERO 1
135
136 /* This is certainly true.  Should it be defined?  (It wasn't before.) */
137 /* #define LARGEST_EXPONENT_IS_NORMAL(size) (size != 32) */
138
139 \f
140 /* Type Layout */
141
142 #define INT_TYPE_SIZE 32
143
144 #define LONG_TYPE_SIZE 32
145
146 #define LONG_LONG_TYPE_SIZE 64
147
148 #define FLOAT_TYPE_SIZE 32
149
150 #define DOUBLE_TYPE_SIZE 64
151
152 #define LONG_DOUBLE_TYPE_SIZE 64
153
154 #define DEFAULT_SIGNED_CHAR 0
155
156 \f
157 /* Register Basics */
158
159 /* 128-130 are special registers that never appear in assembly code. */
160 #define FIRST_PSEUDO_REGISTER 131
161
162 #define FIXED_REGISTERS {                           \
163     1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
164     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
165     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
166     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
167     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
168     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
169     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
170     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
171     1, 1, 1 \
172 }
173
174 #define CALL_USED_REGISTERS {                       \
175     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
176     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
177     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
178     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
179     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \
180     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
181     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
182     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \
183     1, 1, 1 \
184 }
185
186 #define CONDITIONAL_REGISTER_USAGE \
187         spu_conditional_register_usage()
188
189 \f
190 /* Values in Registers */
191
192 #define HARD_REGNO_NREGS(REGNO, MODE)   \
193     ((GET_MODE_BITSIZE(MODE)+MAX_FIXED_MODE_SIZE-1)/MAX_FIXED_MODE_SIZE)
194
195 #define HARD_REGNO_MODE_OK(REGNO, MODE) 1
196
197 #define MODES_TIEABLE_P(MODE1, MODE2) \
198   (GET_MODE_BITSIZE (MODE1) <= MAX_FIXED_MODE_SIZE \
199    && GET_MODE_BITSIZE (MODE2) <= MAX_FIXED_MODE_SIZE)
200
201 \f
202 /* Register Classes */
203
204 enum reg_class { 
205    NO_REGS, 
206    GENERAL_REGS,
207    ALL_REGS,
208    LIM_REG_CLASSES 
209 };
210
211 #define N_REG_CLASSES (int) LIM_REG_CLASSES
212
213 #define REG_CLASS_NAMES \
214 {  "NO_REGS", \
215    "GENERAL_REGS", \
216    "ALL_REGS" \
217 }
218
219 #define REG_CLASS_CONTENTS { \
220     {0, 0, 0, 0, 0}, /* no regs */ \
221     {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x3}, /* general regs */ \
222     {0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0x3}} /* all regs */
223
224 #define REGNO_REG_CLASS(REGNO) (GENERAL_REGS)
225
226 #define BASE_REG_CLASS GENERAL_REGS
227
228 #define INDEX_REG_CLASS GENERAL_REGS
229
230 #define REGNO_OK_FOR_BASE_P(regno) \
231    ((regno) < FIRST_PSEUDO_REGISTER || (regno > LAST_VIRTUAL_REGISTER && reg_renumber[regno] >= 0))
232
233 #define REGNO_OK_FOR_INDEX_P(regno)  \
234    ((regno) < FIRST_PSEUDO_REGISTER || (regno > LAST_VIRTUAL_REGISTER && reg_renumber[regno] >= 0))
235
236 #define INT_REG_OK_FOR_INDEX_P(X,STRICT) \
237         ((!(STRICT) || REGNO_OK_FOR_INDEX_P (REGNO (X))))
238 #define INT_REG_OK_FOR_BASE_P(X,STRICT) \
239         ((!(STRICT) || REGNO_OK_FOR_BASE_P (REGNO (X))))
240
241 #define PREFERRED_RELOAD_CLASS(X,CLASS)  (CLASS)
242
243 #define CLASS_MAX_NREGS(CLASS, MODE)    \
244         ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
245
246 /* GCC assumes that modes are in the lowpart of a register, which is
247    only true for SPU. */
248 #define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
249         ((GET_MODE_SIZE (FROM) > 4 || GET_MODE_SIZE (TO) > 4) \
250          && GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO))
251
252 #define REGISTER_TARGET_PRAGMAS() do {                                  \
253 targetm.resolve_overloaded_builtin = spu_resolve_overloaded_builtin;    \
254 }while (0);
255
256 \f
257 /* Frame Layout */
258
259 #define STACK_GROWS_DOWNWARD
260
261 #define STARTING_FRAME_OFFSET (0)
262
263 #define STACK_POINTER_OFFSET 32
264
265 #define FIRST_PARM_OFFSET(FNDECL) (0)
266
267 #define DYNAMIC_CHAIN_ADDRESS(FP) plus_constant ((FP), -16)
268
269 #define RETURN_ADDR_RTX(COUNT,FP) (spu_return_addr (COUNT, FP))
270
271 /* Should this be defined?  Would it simplify our implementation. */
272 /* #define RETURN_ADDR_IN_PREVIOUS_FRAME */
273
274 #define INCOMING_RETURN_ADDR_RTX gen_rtx_REG(Pmode, LINK_REGISTER_REGNUM)
275
276 #define ARG_POINTER_CFA_OFFSET(FNDECL) (-STACK_POINTER_OFFSET)
277
278 \f
279 /* Stack Checking */
280
281 /* We store the Available Stack Size in the second slot of the stack
282    register.   We emit stack checking code during the prologue.  */
283 #define STACK_CHECK_BUILTIN 1
284
285 \f
286 /* Frame Registers, and other registers */
287
288 #define STACK_POINTER_REGNUM 1
289
290 /* Will be eliminated. */
291 #define FRAME_POINTER_REGNUM 128
292
293 /* This is not specified in any ABI, so could be set to anything. */
294 #define HARD_FRAME_POINTER_REGNUM 127
295
296 /* Will be eliminated. */
297 #define ARG_POINTER_REGNUM 129
298
299 #define STATIC_CHAIN_REGNUM 2
300
301 #define LINK_REGISTER_REGNUM 0
302
303 /* Used to keep track of instructions that have clobbered the hint
304  * buffer.  Users can also specify it in inline asm. */
305 #define HBR_REGNUM 130
306
307 #define MAX_REGISTER_ARGS    72
308 #define FIRST_ARG_REGNUM     3
309 #define LAST_ARG_REGNUM      (FIRST_ARG_REGNUM + MAX_REGISTER_ARGS - 1)
310
311 #define MAX_REGISTER_RETURN  72
312 #define FIRST_RETURN_REGNUM  3
313 #define LAST_RETURN_REGNUM   (FIRST_RETURN_REGNUM + MAX_REGISTER_RETURN - 1)
314
315 \f
316 /* Elimination */
317
318 #define FRAME_POINTER_REQUIRED 0
319
320 #define INITIAL_FRAME_POINTER_OFFSET(DEPTH) ((DEPTH) = 0)
321
322 #define ELIMINABLE_REGS  \
323   {{ARG_POINTER_REGNUM,  STACK_POINTER_REGNUM},                         \
324   {ARG_POINTER_REGNUM,   HARD_FRAME_POINTER_REGNUM},                    \
325   {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM},                         \
326   {FRAME_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM}}
327
328 #define CAN_ELIMINATE(FROM,TO) 1 
329
330 #define INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET) \
331   ((OFFSET) = spu_initial_elimination_offset((FROM),(TO)))
332
333 \f
334 /* Stack Arguments */
335
336 #define ACCUMULATE_OUTGOING_ARGS 1
337
338 #define REG_PARM_STACK_SPACE(FNDECL) 0
339
340 #define OUTGOING_REG_PARM_STACK_SPACE 
341
342 #define RETURN_POPS_ARGS(FUNDECL,FUNTYPE,SIZE) (0)
343
344 \f
345 /* Register Arguments */
346
347 #define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
348         (spu_function_arg((CUM),(MODE),(TYPE),(NAMED)))
349
350 #define CUMULATIVE_ARGS int
351
352 #define INIT_CUMULATIVE_ARGS(CUM,FNTYPE,LIBNAME,FNDECL,N_NAMED_ARGS) \
353                 ((CUM) = 0)
354
355 #define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED)    \
356         ((CUM) += \
357          (TYPE) && TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST ? 1 \
358          : (MODE) == BLKmode ? ((int_size_in_bytes(TYPE)+15) / 16) \
359          : (MODE) == VOIDmode ? 1 \
360          : HARD_REGNO_NREGS(CUM,MODE))
361
362 #define FUNCTION_ARG_PADDING(MODE,TYPE) upward
363
364 #define PAD_VARARGS_DOWN 0
365
366 #define FUNCTION_ARG_REGNO_P(N) ((N) >= (FIRST_ARG_REGNUM) && (N) <= (LAST_ARG_REGNUM))
367
368 /* Undocumented */
369 #define EXPAND_BUILTIN_VA_START(valist, nextarg) \
370   spu_va_start (valist, nextarg)
371
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 spu_branch_cost
449
450 #define SLOW_BYTE_ACCESS 0
451
452 #define MOVE_RATIO 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 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
503 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 10),    \
504   sprintf ((OUTPUT), "%s.%d", (NAME), (LABELNO)))
505
506 \f
507 /* Instruction Output */
508 #define REGISTER_NAMES \
509 {"$lr", "$sp", "$2", "$3", "$4", "$5", "$6", "$7", "$8", "$9", "$10", "$11", "$12", "$13", "$14", "$15", \
510  "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23", "$24", "$25", "$26", "$27", "$28", "$29", "$30", "$31", \
511  "$32", "$33", "$34", "$35", "$36", "$37", "$38", "$39", "$40", "$41", "$42", "$43", "$44", "$45", "$46", "$47", \
512  "$48", "$49", "$50", "$51", "$52", "$53", "$54", "$55", "$56", "$57", "$58", "$59", "$60", "$61", "$62", "$63", \
513  "$64", "$65", "$66", "$67", "$68", "$69", "$70", "$71", "$72", "$73", "$74", "$75", "$76", "$77", "$78", "$79", \
514  "$80", "$81", "$82", "$83", "$84", "$85", "$86", "$87", "$88", "$89", "$90", "$91", "$92", "$93", "$94", "$95", \
515  "$96", "$97", "$98", "$99", "$100", "$101", "$102", "$103", "$104", "$105", "$106", "$107", "$108", "$109", "$110", "$111", \
516  "$112", "$113", "$114", "$115", "$116", "$117", "$118", "$119", "$120", "$121", "$122", "$123", "$124", "$125", "$126", "$127", \
517  "$vfp", "$vap", "hbr" \
518 }
519
520 #define PRINT_OPERAND(FILE, X, CODE)  print_operand(FILE, X, CODE)
521
522 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
523  print_operand_address (FILE, ADDR)
524
525 #define LOCAL_LABEL_PREFIX "."
526
527 #define USER_LABEL_PREFIX ""
528
529 \f
530 /* Dispatch Tables */
531
532 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)  \
533   fprintf (FILE, "\t.word .L%d-.L%d\n", VALUE, REL)
534
535 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
536   fprintf (FILE, "\t.word .L%d\n", VALUE)
537
538 \f
539 /* Alignment Output */
540
541 #define ASM_OUTPUT_ALIGN(FILE,LOG)  \
542   do { if (LOG!=0) fprintf (FILE, "\t.align\t%d\n", (LOG)); } while (0)
543
544 \f
545 /* Misc */
546
547 #define CASE_VECTOR_MODE SImode
548
549 #define MOVE_MAX 16 
550
551 #define TRULY_NOOP_TRUNCATION(OUTPREC, INPREC) ((INPREC) <= 32 && (OUTPREC) <= (INPREC))
552
553 #define STORE_FLAG_VALUE -1
554
555 #define Pmode SImode
556
557 #define FUNCTION_MODE QImode
558
559 #define NO_IMPLICIT_EXTERN_C 1
560
561 #define HANDLE_PRAGMA_PACK_PUSH_POP 1
562 \f
563
564 /* These are set by the cmp patterns and used while expanding
565    conditional branches. */
566 extern GTY(()) rtx spu_compare_op0;
567 extern GTY(()) rtx spu_compare_op1;
568