gcc/config/spu/spu.h

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