gcc/config/spu/spu.h

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