OSDN Git Service

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