gcc/config/m68k/hp320.h

   1 /* Definitions of target machine for GNU compiler.  HP-UX 68000/68020 version.
   2    Copyright (C) 1987, 1988 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* Define USE_GAS if GCC is supposed to work with the GNU assembler,
  21    GNU linker and GNU debugger using DBX debugging information.
  22    (In other words, much of HPUX has been cast aside.)
  23    Undefine USE_GAS if you want GCC to feed the HP assembler.  */
  24
  25 /* #define USE_GAS */  /* Use hp320g.h if you want this.  */
  26
  27 /* Control assembler-syntax conditionals in m68k.md.  */
  28
  29 #ifndef USE_GAS
  30 #define MOTOROLA                /* Use Motorola syntax rather than "MIT" */
  31 #define SGS                     /* Uses SGS assembler */
  32 #define SGS_CMP_ORDER           /* Takes cmp operands in reverse order */
  33 #define HPUX_ASM
  34 #endif
  35
  36 /* Be compatible with system stddef.h.  */
  37 #define SIZE_TYPE "unsigned int"
  38
  39 /* Use atexit for static constructors/destructors, instead of defining
  40    our own exit function.  */
  41 #define HAVE_ATEXIT
  42
  43 #include "m68k.h"
  44
  45 /* See m68k.h.  7 means 68020 with 68881.  */
  46
  47 #ifndef TARGET_DEFAULT
  48 #define TARGET_DEFAULT 7
  49 #endif
  50
  51 /* Define __HAVE_68881__ in preprocessor, unless -msoft-float is specified.
  52    This will control the use of inline 68881 insns in certain macros.  */
  53
  54 #ifdef HPUX_ASM
  55
  56 #define ASM_SPEC "%{m68000:+X}%{mc68000:+X}"
  57
  58 #if TARGET_DEFAULT & 02  /* -m68881 is the default */
  59
  60 /* These definitions differ from those used for GAS by defining __HPUX_ASM__.
  61    This is needed because some programs, particularly GDB, need to
  62    know which assembler is being used so that the correct `asm'
  63    instructions can be used. */
  64
  65 #define CPP_SPEC \
  66 "%{!msoft-float:-D__HAVE_68881__ }\
  67 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE} -D__HPUX_ASM__"
  68
  69 #else /* default is -msoft-float */
  70
  71 #define CPP_SPEC \
  72 "%{m68881:-D__HAVE_68881__ }\
  73 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE} -D__HPUX_ASM__"
  74
  75 #endif /* default is -msoft-float */
  76
  77 #else /* not HPUX_ASM */
  78
  79 #if TARGET_DEFAULT & 02  /* -m68881 is the default */
  80
  81 #define CPP_SPEC \
  82 "%{!msoft-float:-D__HAVE_68881__ }\
  83 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE}"
  84
  85 #else /* default is -msoft-float */
  86
  87 #define CPP_SPEC \
  88 "%{m68881:-D__HAVE_68881__ }\
  89 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE}"
  90
  91 #endif /* default is -msoft-float */
  92
  93
  94 /* -m68000 requires special flags to the assembler.  */
  95 #define ASM_SPEC \
  96  "%{m68000:-mc68000}%{mc68000:-mc68000}%{!mc68000:%{!m68000:-mc68020}}"
  97
  98 /* Tell GCC to put a space after -L when generating such options.  */
  99 #define SPACE_AFTER_L_OPTION
 100
 101 #endif /* Not HPUX_ASM */
 102
 103 /* Names to predefine in the preprocessor for this target machine
 104    (for non-strict-ANSI programs only).  */
 105 /* These are the ones defined by HPUX cc, plus mc68000 for uniformity with
 106    GCC on other 68000 systems.  */
 107
 108 #define CPP_PREDEFINES "-Dhp9000s200 -Dhp9000s300 -DPWB -Dhpux -Dunix -D__hp9000s300 -D__hp9000s200 -D__PWB -D__hpux -D__unix"
 109
 110 /* Every structure or union's size must be a multiple of 2 bytes.  */
 111
 112 #define STRUCTURE_SIZE_BOUNDARY 16
 113
 114 /* hpux doesn't use static area for struct returns. */
 115 #undef PCC_STATIC_STRUCT_RETURN
 116
 117 /* Generate calls to memcpy, memcmp and memset.  */
 118 #define TARGET_MEM_FUNCTIONS
 119
 120 #if 0  /* No longer correct in HPUX version 6.5.  */
 121 /* Function calls don't save any fp registers on hpux.  */
 122 #undef CALL_USED_REGISTERS
 123 #define CALL_USED_REGISTERS                                             \
 124  {1, 1, 0, 0, 0, 0, 0, 0,                                               \
 125   1, 1, 0, 0, 0, 0, 0, 1,                                               \
 126   1, 1, 1, 1, 1, 1, 1, 1}
 127 #endif /* 0 */
 128
 129 #ifdef HPUX_ASM
 130
 131 /* Override parts of m68k.h to fit the HPUX assembler.  */
 132
 133 #undef TARGET_VERSION
 134 #undef REGISTER_NAMES
 135 #undef FUNCTION_PROLOGUE
 136 #undef FUNCTION_EPILOGUE
 137 #undef ASM_OUTPUT_REG_PUSH
 138 #undef ASM_OUTPUT_REG_POP
 139 #undef ASM_FILE_START
 140 #undef ASM_APP_ON
 141 #undef ASM_APP_OFF
 142 #undef TEXT_SECTION_ASM_OP
 143 #undef DATA_SECTION_ASM_OP
 144 #undef ASM_OUTPUT_DOUBLE
 145 #undef ASM_OUTPUT_FLOAT
 146 #undef ASM_OUTPUT_INT
 147 #undef ASM_OUTPUT_SHORT
 148 #undef ASM_OUTPUT_CHAR
 149 #undef ASM_OUTPUT_BYTE
 150 #undef ASM_OUTPUT_ADDR_VEC_ELT
 151 #undef ASM_OUTPUT_ADDR_DIFF_ELT
 152 #undef ASM_OUTPUT_ALIGN
 153 #undef ASM_OUTPUT_SKIP
 154 #undef ASM_OUTPUT_COMMON
 155 #undef ASM_OUTPUT_LOCAL
 156 #undef ASM_FORMAT_PRIVATE_NAME
 157 #undef PRINT_OPERAND
 158 #undef PRINT_OPERAND_ADDRESS
 159 #undef FUNCTION_PROFILER
 160 #undef ASM_GLOBALIZE_LABEL
 161 #undef ASM_OUTPUT_INTERNAL_LABEL
 162
 163 #define TARGET_VERSION fprintf (stderr, " (68k, SGS/hpux syntax)");
 164
 165 #define REGISTER_NAMES \
 166 {"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",        \
 167  "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp",        \
 168  "%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7"}
 169
 170 #define FUNCTION_PROLOGUE(FILE, SIZE)     \
 171 { register int regno;                                           \
 172   register int mask = 0;                                        \
 173   extern char call_used_regs[];                                 \
 174   int fsize = (SIZE);                                           \
 175   if (frame_pointer_needed)                                     \
 176     { if (fsize < 0x8000)                                       \
 177         fprintf (FILE, "\tlink.w %%a6,&%d\n", -fsize);          \
 178       else if (TARGET_68020)                                    \
 179         fprintf (FILE, "\tlink.l %%a6,&%d\n", -fsize);          \
 180       else                                                      \
 181         fprintf (FILE, "\tlink.w %%a6,&0\n\tsub.l &%d,%%sp\n", fsize); }  \
 182   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 183     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 184        mask |= 1 << (regno - 16);                               \
 185   if (mask != 0)                                                \
 186     fprintf (FILE, "\tfmovem &0x%x,-(%%sp)\n", mask & 0xff);       \
 187   mask = 0;                                                     \
 188   for (regno = 0; regno < 16; regno++)                          \
 189     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 190        mask |= 1 << (15 - regno);                               \
 191   if (frame_pointer_needed)                                     \
 192     mask &= ~ (1 << (15-FRAME_POINTER_REGNUM));                 \
 193   if (exact_log2 (mask) >= 0)                                   \
 194     fprintf (FILE, "\tmov.l %s,-(%%sp)\n", reg_names[15 - exact_log2 (mask)]);  \
 195   else if (mask) fprintf (FILE, "\tmovm.l &0x%x,-(%%sp)\n", mask); }
 196
 197 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 198    fprintf (FILE, "\tmov.l &LP%d,%%a0\n\tjsr mcount\n", (LABEL_NO));
 199
 200 #define FUNCTION_EPILOGUE(FILE, SIZE) \
 201 { register int regno;                                           \
 202   register int mask, fmask;                                     \
 203   register int nregs;                                           \
 204   int offset, foffset;                                          \
 205   extern char call_used_regs[];                                 \
 206   int fsize = (SIZE);                                           \
 207   int big = 0;                                                  \
 208   nregs = 0;  fmask = 0;                                        \
 209   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 210     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 211       { nregs++; fmask |= 1 << (23 - regno); }                  \
 212   foffset = nregs * 12;                                         \
 213   nregs = 0;  mask = 0;                                         \
 214   if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
 215   for (regno = 0; regno < 16; regno++)                          \
 216     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 217       { nregs++; mask |= 1 << regno; }                          \
 218   offset = foffset + nregs * 4;                                 \
 219   if (offset + fsize >= 0x8000 && frame_pointer_needed)         \
 220     { fprintf (FILE, "\tmov.l &%d,%%a0\n", -fsize);             \
 221       fsize = 0, big = 1; }                                     \
 222   if (exact_log2 (mask) >= 0) {                                 \
 223     if (big)                                                    \
 224       fprintf (FILE, "\tmov.l -%d(%%a6,%%a0.l),%s\n",           \
 225                offset + fsize, reg_names[exact_log2 (mask)]);   \
 226     else if (! frame_pointer_needed)                            \
 227       fprintf (FILE, "\tmov.l (%%sp)+,%s\n",                    \
 228                reg_names[exact_log2 (mask)]);                   \
 229     else                                                        \
 230       fprintf (FILE, "\tmov.l -%d(%%a6),%s\n",                  \
 231                offset + fsize, reg_names[exact_log2 (mask)]); } \
 232   else if (mask) {                                              \
 233     if (big)                                                    \
 234       fprintf (FILE, "\tmovm.l -%d(%%a6,%%a0.l),&0x%x\n",       \
 235                offset + fsize, mask);                           \
 236     else if (! frame_pointer_needed)                            \
 237       fprintf (FILE, "\tmovm.l (%%sp)+,&0x%x\n", mask);         \
 238     else                                                        \
 239       fprintf (FILE, "\tmovm.l -%d(%%a6),&0x%x\n",              \
 240                offset + fsize, mask); }                         \
 241   if (fmask) {                                                  \
 242     if (big)                                                    \
 243       fprintf (FILE, "\tfmovem -%d(%%a6,%%a0.l),&0x%x\n",       \
 244                foffset + fsize, fmask);                         \
 245     else if (! frame_pointer_needed)                            \
 246       fprintf (FILE, "\tfmovem (%%sp)+,&0x%x\n", fmask);        \
 247     else                                                        \
 248       fprintf (FILE, "\tfmovem -%d(%%a6),&0x%x\n",              \
 249                foffset + fsize, fmask); }                       \
 250   if (frame_pointer_needed)                                     \
 251     fprintf (FILE, "\tunlk %%a6\n");                            \
 252   if (current_function_pops_args)                               \
 253     fprintf (FILE, "\trtd &%d\n", current_function_pops_args);  \
 254   else fprintf (FILE, "\trts\n"); }
 255
 256 /* This is how to output an insn to push a register on the stack.
 257    It need not be very fast code.  */
 258
 259 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
 260   fprintf (FILE, "\tmov.l %s,-(%%sp)\n", reg_names[REGNO])
 261
 262 /* This is how to output an insn to pop a register from the stack.
 263    It need not be very fast code.  */
 264
 265 #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
 266   fprintf (FILE, "\tmov.l (%%sp)+,%s\n", reg_names[REGNO])
 267
 268 /* For HPUX versions before 6.5, define this macro as empty.  */
 269 #define ASM_FILE_START(FILE)                                            \
 270   if (TARGET_68020)                                                     \
 271     {                                                                   \
 272       if (TARGET_68881)                                                 \
 273          fprintf (FILE, "\tversion 3\n"); /* 68020 fp regs saved */     \
 274       else                                                              \
 275          fprintf (FILE, "\tversion 2\n"); /* 68020 no fp regs saved */  \
 276     }                                                                   \
 277   else                                                                  \
 278     fprintf (FILE, "\tversion 1\n");    /* 68010 */
 279
 280 #define ASM_APP_ON ""
 281
 282 #define ASM_APP_OFF ""
 283
 284 #define TEXT_SECTION_ASM_OP "text"
 285
 286 #define DATA_SECTION_ASM_OP "data"
 287
 288 #define ASCII_DATA_ASM_OP "\tbyte"
 289
 290 /* This says how to output an assembler line
 291    to define a global common symbol.  */
 292
 293 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
 294 ( fputs ("\tcomm ", (FILE)),                    \
 295   assemble_name ((FILE), (NAME)),               \
 296   fprintf ((FILE), ",%u\n", (ROUNDED)))
 297
 298 /* This says how to output an assembler line
 299    to define a local common symbol.  */
 300
 301 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
 302 ( fputs ("\tlcomm ", (FILE)),                   \
 303   assemble_name ((FILE), (NAME)),               \
 304   fprintf ((FILE), ",%u,2\n", (ROUNDED)))
 305
 306 /* Store in OUTPUT a string (made with alloca) containing
 307    an assembler-name for a local static variable named NAME.
 308    LABELNO is an integer which is different for each call.  */
 309
 310 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 311 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),    \
 312   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
 313
 314 /* This is how to output a command to make the user-level label named NAME
 315    defined for reference from other files.  */
 316
 317 #define ASM_GLOBALIZE_LABEL(FILE,NAME)  \
 318   do { fputs ("\tglobal ", FILE); assemble_name (FILE, NAME); fputs ("\n", FILE);} while (0)
 319
 320 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)      \
 321 do{  if (PREFIX[0] == 'L' && PREFIX[1] == 'I')          \
 322     fprintf(FILE, "\tset %s%d,.+2\n", PREFIX, NUM);     \
 323   else                                                  \
 324     fprintf (FILE, "%s%d:\n", PREFIX, NUM);             \
 325 } while(0)
 326
 327 #define ASM_OUTPUT_DOUBLE(FILE, VALUE)                                  \
 328   fprintf (FILE, "\tdouble 0f%.20g\n", (VALUE))
 329
 330 #define ASM_OUTPUT_FLOAT(FILE, VALUE)                                   \
 331   fprintf (FILE, "\tfloat 0f%.9g\n", (VALUE))
 332
 333 /* This is how to output an assembler line defining an `int' constant.  */
 334
 335 #define ASM_OUTPUT_INT(FILE,VALUE)  \
 336 ( fprintf (FILE, "\tlong "),                    \
 337   output_addr_const (FILE, (VALUE)),            \
 338   fprintf (FILE, "\n"))
 339
 340 /* Likewise for `char' and `short' constants.  */
 341
 342 #define ASM_OUTPUT_SHORT(FILE,VALUE)  \
 343 ( fprintf (FILE, "\tshort "),                   \
 344   output_addr_const (FILE, (VALUE)),            \
 345   fprintf (FILE, "\n"))
 346
 347 #define ASM_OUTPUT_CHAR(FILE,VALUE)  \
 348 ( fprintf (FILE, "\tbyte "),                    \
 349   output_addr_const (FILE, (VALUE)),            \
 350   fprintf (FILE, "\n"))
 351
 352 /* This is how to output an assembler line for a numeric constant byte.  */
 353
 354 #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
 355   fprintf (FILE, "\tbyte 0x%x\n", (VALUE))
 356
 357 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
 358   fprintf (FILE, "\tlong L%d\n", VALUE)
 359
 360 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)  \
 361   fprintf (FILE, "\tshort L%d-L%d\n", VALUE, REL)
 362
 363 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 364   if ((LOG) == 1)                       \
 365     fprintf (FILE, "\tlalign 2\n");     \
 366   else if ((LOG) != 0)                  \
 367     abort ();
 368
 369 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
 370   fprintf (FILE, "\tspace %u\n", (SIZE))
 371
 372 #define ASM_OUTPUT_SOURCE_FILENAME(FILE, FILENAME)
 373 #define ASM_OUTPUT_SOURCE_LINE(FILE, LINENO)
 374
 375 #define PRINT_OPERAND(FILE, X, CODE)  \
 376 { if (CODE == '.') fprintf (FILE, ".");                                 \
 377   else if (CODE == '#') fprintf (FILE, "&");                            \
 378   else if (CODE == '-') fprintf (FILE, "-(%%sp)");                      \
 379   else if (CODE == '+') fprintf (FILE, "(%%sp)+");                      \
 380   else if (CODE == '@') fprintf (FILE, "(%%sp)");                       \
 381   else if (CODE == '!') fprintf (FILE, "%%cc");                         \
 382   else if (CODE == '$') { if (TARGET_68040_ONLY) fprintf (FILE, "s"); } \
 383   else if (CODE == '&') { if (TARGET_68040_ONLY) fprintf (FILE, "d"); } \
 384   else if (GET_CODE (X) == REG)                                         \
 385     fprintf (FILE, "%s", reg_names[REGNO (X)]);                         \
 386   else if (GET_CODE (X) == MEM)                                         \
 387     output_address (XEXP (X, 0));                                       \
 388   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)      \
 389     { union { double d; int i[2]; } u;                                  \
 390       union { float f; int i; } u1;                                     \
 391       u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);    \
 392       u1.f = u.d;                                                       \
 393       if (CODE == 'f')                                                  \
 394         fprintf (FILE, "&0f%.9g", u1.f);                                \
 395       else                                                              \
 396         fprintf (FILE, "&0x%x", u1.i); }                                \
 397   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode)      \
 398     { union { double d; int i[2]; } u;                                  \
 399       u.i[0] = CONST_DOUBLE_LOW (X); u.i[1] = CONST_DOUBLE_HIGH (X);    \
 400       fprintf (FILE, "&0f%.20g", u.d); }                                \
 401   else { putc ('&', FILE); output_addr_const (FILE, X); }}
 402
 403 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
 404 { register rtx reg1, reg2, breg, ireg;                                  \
 405   register rtx addr = ADDR;                                             \
 406   rtx offset;                                                           \
 407   switch (GET_CODE (addr))                                              \
 408     {                                                                   \
 409     case REG:                                                           \
 410       fprintf (FILE, "(%s)", reg_names[REGNO (addr)]);                  \
 411       break;                                                            \
 412     case PRE_DEC:                                                       \
 413       fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);       \
 414       break;                                                            \
 415     case POST_INC:                                                      \
 416       fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);       \
 417       break;                                                            \
 418     case PLUS:                                                          \
 419       reg1 = 0; reg2 = 0;                                               \
 420       ireg = 0; breg = 0;                                               \
 421       offset = 0;                                                       \
 422       if (CONSTANT_ADDRESS_P (XEXP (addr, 0)))                          \
 423         {                                                               \
 424           offset = XEXP (addr, 0);                                      \
 425           addr = XEXP (addr, 1);                                        \
 426         }                                                               \
 427       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)))                     \
 428         {                                                               \
 429           offset = XEXP (addr, 1);                                      \
 430           addr = XEXP (addr, 0);                                        \
 431         }                                                               \
 432       if (GET_CODE (addr) != PLUS) ;                                    \
 433       else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND)                \
 434         {                                                               \
 435           reg1 = XEXP (addr, 0);                                        \
 436           addr = XEXP (addr, 1);                                        \
 437         }                                                               \
 438       else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND)                \
 439         {                                                               \
 440           reg1 = XEXP (addr, 1);                                        \
 441           addr = XEXP (addr, 0);                                        \
 442         }                                                               \
 443       else if (GET_CODE (XEXP (addr, 0)) == MULT)                       \
 444         {                                                               \
 445           reg1 = XEXP (addr, 0);                                        \
 446           addr = XEXP (addr, 1);                                        \
 447         }                                                               \
 448       else if (GET_CODE (XEXP (addr, 1)) == MULT)                       \
 449         {                                                               \
 450           reg1 = XEXP (addr, 1);                                        \
 451           addr = XEXP (addr, 0);                                        \
 452         }                                                               \
 453       else if (GET_CODE (XEXP (addr, 0)) == REG)                        \
 454         {                                                               \
 455           reg1 = XEXP (addr, 0);                                        \
 456           addr = XEXP (addr, 1);                                        \
 457         }                                                               \
 458       else if (GET_CODE (XEXP (addr, 1)) == REG)                        \
 459         {                                                               \
 460           reg1 = XEXP (addr, 1);                                        \
 461           addr = XEXP (addr, 0);                                        \
 462         }                                                               \
 463       if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT             \
 464           || GET_CODE (addr) == SIGN_EXTEND)                            \
 465         { if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; }     \
 466 /*  for OLD_INDEXING                                                    \
 467       else if (GET_CODE (addr) == PLUS)                                 \
 468         {                                                               \
 469           if (GET_CODE (XEXP (addr, 0)) == REG)                         \
 470             {                                                           \
 471               reg2 = XEXP (addr, 0);                                    \
 472               addr = XEXP (addr, 1);                                    \
 473             }                                                           \
 474           else if (GET_CODE (XEXP (addr, 1)) == REG)                    \
 475             {                                                           \
 476               reg2 = XEXP (addr, 1);                                    \
 477               addr = XEXP (addr, 0);                                    \
 478             }                                                           \
 479         }                                                               \
 480   */                                                                    \
 481       if (offset != 0) { if (addr != 0) abort (); addr = offset; }      \
 482       if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND                      \
 483                     || GET_CODE (reg1) == MULT))                        \
 484           || (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2))))         \
 485         { breg = reg2; ireg = reg1; }                                   \
 486       else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1)))         \
 487         { breg = reg1; ireg = reg2; }                                   \
 488       if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF)       \
 489         { int scale = 1;                                                \
 490           if (GET_CODE (ireg) == MULT)                                  \
 491             { scale = INTVAL (XEXP (ireg, 1));                          \
 492               ireg = XEXP (ireg, 0); }                                  \
 493           if (GET_CODE (ireg) == SIGN_EXTEND)                           \
 494             fprintf (FILE, "L%d-LI%d(%%pc,%s.w",                        \
 495                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 496                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 497                      reg_names[REGNO (XEXP (ireg, 0))]);                \
 498           else                                                          \
 499             fprintf (FILE, "L%d-LI%d(%%pc,%s.l",                        \
 500                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 501                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 502                      reg_names[REGNO (ireg)]);                          \
 503           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 504           putc (')', FILE);                                             \
 505           break; }                                                      \
 506       if (ireg != 0 || breg != 0)                                       \
 507         { int scale = 1;                                                \
 508           if (breg == 0)                                                \
 509             abort ();                                                   \
 510           if (addr != 0)                                                \
 511             output_addr_const (FILE, addr);                             \
 512           fprintf (FILE, "(%s", reg_names[REGNO (breg)]);               \
 513           if (ireg != 0)                                                \
 514             putc (',', FILE);                                           \
 515           if (ireg != 0 && GET_CODE (ireg) == MULT)                     \
 516             { scale = INTVAL (XEXP (ireg, 1));                          \
 517               ireg = XEXP (ireg, 0); }                                  \
 518           if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND)              \
 519             fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]);  \
 520           else if (ireg != 0)                                           \
 521             fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]);            \
 522           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 523           putc (')', FILE);                                             \
 524           break;                                                        \
 525         }                                                               \
 526       else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF)               \
 527         { fprintf (FILE, "L%d-LI%d(%%pc,%s.w)",                         \
 528                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 529                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 530                    reg_names[REGNO (reg1)]);                            \
 531           break; }                                                      \
 532     default:                                                            \
 533       if (GET_CODE (addr) == CONST_INT                                  \
 534           && INTVAL (addr) < 0x8000                                     \
 535           && INTVAL (addr) >= -0x8000)                                  \
 536         fprintf (FILE, "%d.w", INTVAL (addr));                          \
 537       else                                                              \
 538         output_addr_const (FILE, addr);                                 \
 539     }}
 540
 541 #define ASM_OUTPUT_ASCII(f, p, size)    \
 542 { register int i;                       \
 543   int inside;                           \
 544   inside = FALSE;                       \
 545   for (i = 0; i < (size); i++) {        \
 546     if (i % 8 == 0) {                   \
 547       if (i != 0) {                     \
 548         if (inside)                     \
 549           putc('"', (f));               \
 550         putc('\n', (f));                \
 551         inside = FALSE;                 \
 552       }                                 \
 553       fprintf((f), "%s ", ASCII_DATA_ASM_OP);   \
 554     }                                   \
 555     if ((p)[i] < 32 || (p)[i] == '\\' || (p)[i] == '"' || (p)[i] == 127) {      \
 556       if (inside) {                     \
 557         putc('"', (f));                 \
 558         inside = FALSE;                 \
 559       }                                 \
 560       if (i % 8 != 0)                   \
 561         putc(',', (f));                 \
 562       fprintf((f), "%d", (p)[i]);       \
 563     } else {                            \
 564       if (!inside) {                    \
 565         if (i % 8 != 0)                 \
 566           putc(',', (f));               \
 567         putc('"', (f));                 \
 568         inside = TRUE;                  \
 569       }                                 \
 570       putc((p)[i], (f));                \
 571     }                                   \
 572   }                                     \
 573   if (inside)                           \
 574     putc('"', (f));                     \
 575   putc('\n', (f));                      \
 576 }
 577
 578 /* Translate Motorola opcodes such as `jbeq'
 579    into SGS opcodes such as `beq.w'.
 580    Delete the `e' in `move...' and `fmove'.
 581    Change `ftst' to `ftest'.  */
 582
 583 #define ASM_OUTPUT_OPCODE(FILE, PTR)                    \
 584 { if ((PTR)[0] == 'j' && (PTR)[1] == 'b')               \
 585     { ++(PTR);                                          \
 586       while (*(PTR) != ' ')                             \
 587         { putc (*(PTR), (FILE)); ++(PTR); }             \
 588       fprintf ((FILE), ".w"); }                         \
 589   else if ((PTR)[0] == 'f')                             \
 590     {                                                   \
 591       if (!strncmp ((PTR), "fmove", 5))                 \
 592         { fprintf ((FILE), "fmov"); (PTR) += 5; }       \
 593       else if (!strncmp ((PTR), "ftst", 4))             \
 594         { fprintf ((FILE), "ftest"); (PTR) += 4; }      \
 595     }                                                   \
 596   else if ((PTR)[0] == 'm' && (PTR)[1] == 'o'           \
 597            && (PTR)[2] == 'v' && (PTR)[3] == 'e')       \
 598     { fprintf ((FILE), "mov"); (PTR) += 4; }            \
 599 }
 600
 601 /* Prevent output of `gcc_compiled.:'.  */
 602
 603 #define ASM_IDENTIFY_GCC(FILE)
 604
 605 #else /* not HPUX_ASM */
 606
 607 #undef FUNCTION_PROFILER
 608 #define FUNCTION_PROFILER(FILE, LABELNO)  \
 609    fprintf (FILE, "\tmovl #LP%d,d0\n\tjsr mcount\n", (LABELNO));
 610
 611 #endif /* not HPUX_ASM */