gcc/config/spu/spu.h

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