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