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