gcc/config/m68k/hp320.h

   1 /* Definitions of target machine for GNU compiler.  HP-UX 68000/68020 version.
   2    Copyright (C) 1987, 1988, 1993, 1994 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
  35 #if !defined (CROSS_COMPILE) && !defined (NO_BUGS)
  36 /* The assembler on HP 9k3xx machines running HPUX 8.0 doesn't translate
  37    floating point constants behind some operands.  The workaround is to
  38    use hex constants.  Reported by Thomas Nau (nau@medizin.uni-ulm.de).  */
  39 #define AS_BUG_FLOATING_CONSTANT
  40 /* The assembler on HP 9k3xx machines running HPUX 8.0 doesn't accept
  41    labels followed by a text, data, or other section directive.  Reported
  42    by Thomas Nau (nau@medizin.uni-ulm.de).  */
  43 #define AS_BUG_TRAILING_LABEL
  44 #endif
  45
  46 #endif /* not USE_GAS */
  47
  48 /* gcc.c should find libgcc.a itself rather than expecting linker to.  */
  49 #define LINK_LIBGCC_SPECIAL
  50 /* The arguments of -L must be a separate argv element.  */
  51 #define SPACE_AFTER_L_OPTION
  52 /* HP/UX doesn't have libg.a.  */
  53 #define LIB_SPEC "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}"
  54
  55 /* Be compatible with system stddef.h.  */
  56 #define SIZE_TYPE "unsigned int"
  57
  58 /* Use atexit for static constructors/destructors, instead of defining
  59    our own exit function.  */
  60 #define HAVE_ATEXIT
  61
  62 #include "m68k/m68k.h"
  63
  64 /* See m68k.h.  7 means 68020 with 68881.  */
  65
  66 #ifndef TARGET_DEFAULT
  67 #define TARGET_DEFAULT 7
  68 #endif
  69
  70 /* Define __HAVE_68881__ in preprocessor, unless -msoft-float is specified.
  71    This will control the use of inline 68881 insns in certain macros.  */
  72
  73 #ifdef HPUX_ASM
  74
  75 #define ASM_SPEC "%{m68000:+X}%{mc68000:+X}"
  76
  77 #if TARGET_DEFAULT & 02  /* -m68881 is the default */
  78
  79 /* These definitions differ from those used for GAS by defining __HPUX_ASM__.
  80    This is needed because some programs, particularly GDB, need to
  81    know which assembler is being used so that the correct `asm'
  82    instructions can be used. */
  83
  84 #define CPP_SPEC \
  85 "%{!msoft-float:-D__HAVE_68881__ }\
  86 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE} -D__HPUX_ASM__"
  87
  88 #else /* default is -msoft-float */
  89
  90 #define CPP_SPEC \
  91 "%{m68881:-D__HAVE_68881__ }\
  92 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE} -D__HPUX_ASM__"
  93
  94 #endif /* default is -msoft-float */
  95
  96 #else /* not HPUX_ASM */
  97
  98 #if TARGET_DEFAULT & 02  /* -m68881 is the default */
  99
 100 #define CPP_SPEC \
 101 "%{!msoft-float:-D__HAVE_68881__ }\
 102 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE}"
 103
 104 #else /* default is -msoft-float */
 105
 106 #define CPP_SPEC \
 107 "%{m68881:-D__HAVE_68881__ }\
 108 %{!ansi:%{!mc68000:%{!m68000:-Dmc68020}} -D_HPUX_SOURCE}"
 109
 110 #endif /* default is -msoft-float */
 111
 112
 113 /* -m68000 requires special flags to the assembler.  */
 114 #define ASM_SPEC \
 115  "%{m68000:-mc68000}%{mc68000:-mc68000}%{!mc68000:%{!m68000:-mc68020}}"
 116
 117 /* Tell GCC to put a space after -L when generating such options.  */
 118 #define SPACE_AFTER_L_OPTION
 119
 120 #endif /* Not HPUX_ASM */
 121
 122 /* Names to predefine in the preprocessor for this target machine
 123    (for non-strict-ANSI programs only).  */
 124 /* These are the ones defined by HPUX cc, plus mc68000 for uniformity with
 125    GCC on other 68000 systems.  */
 126
 127 #define CPP_PREDEFINES "-Dhp9000s200 -Dhp9000s300 -DPWB -Dhpux -Dunix -D__hp9000s300 -D__hp9000s200 -D__PWB -D__hpux -D__unix -D__motorola__ -Asystem(unix) -Asystem(hpux) -Acpu(m68k) -Amachine(m68k)"
 128
 129 /* Every structure or union's size must be a multiple of 2 bytes.  */
 130
 131 #define STRUCTURE_SIZE_BOUNDARY 16
 132
 133 /* hpux doesn't use static area for struct returns. */
 134 #undef PCC_STATIC_STRUCT_RETURN
 135
 136 /* Generate calls to memcpy, memcmp and memset.  */
 137 #define TARGET_MEM_FUNCTIONS
 138
 139 #if 0  /* No longer correct in HPUX version 6.5.  */
 140 /* Function calls don't save any fp registers on hpux.  */
 141 #undef CALL_USED_REGISTERS
 142 #define CALL_USED_REGISTERS                                             \
 143  {1, 1, 0, 0, 0, 0, 0, 0,                                               \
 144   1, 1, 0, 0, 0, 0, 0, 1,                                               \
 145   1, 1, 1, 1, 1, 1, 1, 1}
 146 #endif /* 0 */
 147
 148 #ifdef HPUX_ASM
 149
 150 /* Override parts of m68k.h to fit the HPUX assembler.  */
 151
 152 #undef TARGET_VERSION
 153 #undef REGISTER_NAMES
 154 #undef FUNCTION_PROLOGUE
 155 #undef FUNCTION_EPILOGUE
 156 #undef ASM_OUTPUT_REG_PUSH
 157 #undef ASM_OUTPUT_REG_POP
 158 #undef ASM_FILE_START
 159 #undef ASM_APP_ON
 160 #undef ASM_APP_OFF
 161 #undef TEXT_SECTION_ASM_OP
 162 #undef DATA_SECTION_ASM_OP
 163 #undef READONLY_DATA_SECTION
 164 #undef ASM_OUTPUT_DOUBLE
 165 #undef ASM_OUTPUT_FLOAT
 166 #undef ASM_OUTPUT_INT
 167 #undef ASM_OUTPUT_SHORT
 168 #undef ASM_OUTPUT_CHAR
 169 #undef ASM_OUTPUT_BYTE
 170 #undef ASM_OUTPUT_ADDR_VEC_ELT
 171 #undef ASM_OUTPUT_ADDR_DIFF_ELT
 172 #undef ASM_OUTPUT_ALIGN
 173 #undef ASM_OUTPUT_SKIP
 174 #undef ASM_OUTPUT_COMMON
 175 #undef ASM_OUTPUT_LOCAL
 176 #undef ASM_FORMAT_PRIVATE_NAME
 177 #undef PRINT_OPERAND
 178 #undef PRINT_OPERAND_ADDRESS
 179 #undef FUNCTION_PROFILER
 180 #undef ASM_OUTPUT_INTERNAL_LABEL
 181 #undef GLOBAL_ASM_OP
 182
 183 #define TARGET_VERSION fprintf (stderr, " (68k, SGS/hpux syntax)");
 184
 185 #define REGISTER_NAMES \
 186 {"%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",        \
 187  "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp",        \
 188  "%fp0", "%fp1", "%fp2", "%fp3", "%fp4", "%fp5", "%fp6", "%fp7"}
 189
 190 #define FUNCTION_PROLOGUE(FILE, SIZE)     \
 191 { register int regno;                                           \
 192   register int mask = 0;                                        \
 193   extern char call_used_regs[];                                 \
 194   int fsize = (SIZE);                                           \
 195   if (frame_pointer_needed)                                     \
 196     { if (fsize < 0x8000)                                       \
 197         fprintf (FILE, "\tlink.w %%a6,&%d\n", -fsize);          \
 198       else if (TARGET_68020)                                    \
 199         fprintf (FILE, "\tlink.l %%a6,&%d\n", -fsize);          \
 200       else                                                      \
 201         fprintf (FILE, "\tlink.w %%a6,&0\n\tsub.l &%d,%%sp\n", fsize); }  \
 202   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 203     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 204        mask |= 1 << (regno - 16);                               \
 205   if (mask != 0)                                                \
 206     fprintf (FILE, "\tfmovem &0x%x,-(%%sp)\n", mask & 0xff);       \
 207   mask = 0;                                                     \
 208   for (regno = 0; regno < 16; regno++)                          \
 209     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 210        mask |= 1 << (15 - regno);                               \
 211   if (frame_pointer_needed)                                     \
 212     mask &= ~ (1 << (15-FRAME_POINTER_REGNUM));                 \
 213   if (exact_log2 (mask) >= 0)                                   \
 214     fprintf (FILE, "\tmov.l %s,-(%%sp)\n", reg_names[15 - exact_log2 (mask)]);  \
 215   else if (mask) fprintf (FILE, "\tmovm.l &0x%x,-(%%sp)\n", mask); }\
 216   if (flag_pic && current_function_uses_pic_offset_table)       \
 217     {                                                           \
 218       fprintf (FILE, "\tmov.l &DLT, %s\n",\
 219                    reg_names[PIC_OFFSET_TABLE_REGNUM]);         \
 220       fprintf (FILE, "\tlea.l -0x6(%%pc,%s.l),%s\n",          \
 221                    reg_names[PIC_OFFSET_TABLE_REGNUM],          \
 222                    reg_names[PIC_OFFSET_TABLE_REGNUM]);         \
 223     }
 224
 225 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 226    fprintf (FILE, "\tmov.l &LP%d,%%a0\n\tjsr mcount\n", (LABEL_NO));
 227
 228 #define FUNCTION_EPILOGUE(FILE, SIZE) \
 229 { register int regno;                                           \
 230   register int mask, fmask;                                     \
 231   register int nregs;                                           \
 232   int offset, foffset;                                          \
 233   extern char call_used_regs[];                                 \
 234   int fsize = (SIZE);                                           \
 235   int big = 0;                                                  \
 236   nregs = 0;  fmask = 0;                                        \
 237   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 238     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 239       { nregs++; fmask |= 1 << (23 - regno); }                  \
 240   foffset = nregs * 12;                                         \
 241   nregs = 0;  mask = 0;                                         \
 242   if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
 243   for (regno = 0; regno < 16; regno++)                          \
 244     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 245       { nregs++; mask |= 1 << regno; }                          \
 246   offset = foffset + nregs * 4;                                 \
 247   if (offset + fsize >= 0x8000 && frame_pointer_needed)         \
 248     { fprintf (FILE, "\tmov.l &%d,%%a0\n", -fsize);             \
 249       fsize = 0, big = 1; }                                     \
 250   if (exact_log2 (mask) >= 0) {                                 \
 251     if (big)                                                    \
 252       fprintf (FILE, "\tmov.l -%d(%%a6,%%a0.l),%s\n",           \
 253                offset + fsize, reg_names[exact_log2 (mask)]);   \
 254     else if (! frame_pointer_needed)                            \
 255       fprintf (FILE, "\tmov.l (%%sp)+,%s\n",                    \
 256                reg_names[exact_log2 (mask)]);                   \
 257     else                                                        \
 258       fprintf (FILE, "\tmov.l -%d(%%a6),%s\n",                  \
 259                offset + fsize, reg_names[exact_log2 (mask)]); } \
 260   else if (mask) {                                              \
 261     if (big)                                                    \
 262       fprintf (FILE, "\tmovm.l -%d(%%a6,%%a0.l),&0x%x\n",       \
 263                offset + fsize, mask);                           \
 264     else if (! frame_pointer_needed)                            \
 265       fprintf (FILE, "\tmovm.l (%%sp)+,&0x%x\n", mask);         \
 266     else                                                        \
 267       fprintf (FILE, "\tmovm.l -%d(%%a6),&0x%x\n",              \
 268                offset + fsize, mask); }                         \
 269   if (fmask) {                                                  \
 270     if (big)                                                    \
 271       fprintf (FILE, "\tfmovem -%d(%%a6,%%a0.l),&0x%x\n",       \
 272                foffset + fsize, fmask);                         \
 273     else if (! frame_pointer_needed)                            \
 274       fprintf (FILE, "\tfmovem (%%sp)+,&0x%x\n", fmask);        \
 275     else                                                        \
 276       fprintf (FILE, "\tfmovem -%d(%%a6),&0x%x\n",              \
 277                foffset + fsize, fmask); }                       \
 278   if (frame_pointer_needed)                                     \
 279     fprintf (FILE, "\tunlk %%a6\n");                            \
 280   if (current_function_pops_args)                               \
 281     fprintf (FILE, "\trtd &%d\n", current_function_pops_args);  \
 282   else fprintf (FILE, "\trts\n"); }
 283
 284 /* This is how to output an insn to push a register on the stack.
 285    It need not be very fast code.  */
 286
 287 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
 288   fprintf (FILE, "\tmov.l %s,-(%%sp)\n", reg_names[REGNO])
 289
 290 /* This is how to output an insn to pop a register from the stack.
 291    It need not be very fast code.  */
 292
 293 #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
 294   fprintf (FILE, "\tmov.l (%%sp)+,%s\n", reg_names[REGNO])
 295
 296 /* For HPUX versions before 6.5, define this macro as empty.  */
 297 #define ASM_FILE_START(FILE)                                            \
 298   if (TARGET_68020)                                                     \
 299     {                                                                   \
 300       if (TARGET_68881)                                                 \
 301          fprintf (FILE, "\tversion 3\n"); /* 68020 fp regs saved */     \
 302       else                                                              \
 303          fprintf (FILE, "\tversion 2\n"); /* 68020 no fp regs saved */  \
 304     }                                                                   \
 305   else                                                                  \
 306     fprintf (FILE, "\tversion 1\n");    /* 68010 */
 307
 308 #define ASM_APP_ON ""
 309
 310 #define ASM_APP_OFF ""
 311
 312 #ifdef AS_BUG_TRAILING_LABEL
 313 #define TEXT_SECTION_ASM_OP "\tlalign\t1\ntext"
 314 #define DATA_SECTION_ASM_OP "\tlalign\t1\ndata"
 315 #else
 316 #define TEXT_SECTION_ASM_OP "text"
 317 #define DATA_SECTION_ASM_OP "data"
 318 #endif
 319 #define READONLY_DATA_SECTION data_section
 320 #define ASCII_DATA_ASM_OP "byte"
 321
 322 /* This is the command to make the user-level label named NAME
 323    defined for reference from other files.  */
 324
 325 #define GLOBAL_ASM_OP "global"
 326
 327 /* This says how to output an assembler line
 328    to define a global common symbol.  */
 329
 330 #define ASM_OUTPUT_COMMON(FILE, NAME, SIZE, ROUNDED)  \
 331 ( fputs ("\tcomm ", (FILE)),                    \
 332   assemble_name ((FILE), (NAME)),               \
 333   fprintf ((FILE), ",%u\n", (ROUNDED)))
 334
 335 /* This says how to output an assembler line
 336    to define a local common symbol.  */
 337
 338 #define ASM_OUTPUT_LOCAL(FILE, NAME, SIZE, ROUNDED)  \
 339 ( fputs ("\tlcomm ", (FILE)),                   \
 340   assemble_name ((FILE), (NAME)),               \
 341   fprintf ((FILE), ",%u,2\n", (ROUNDED)))
 342
 343 /* Store in OUTPUT a string (made with alloca) containing
 344    an assembler-name for a local static variable named NAME.
 345    LABELNO is an integer which is different for each call.  */
 346
 347 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 348 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 12),    \
 349   sprintf ((OUTPUT), "%s___%d", (NAME), (LABELNO)))
 350
 351 #define ASM_OUTPUT_INTERNAL_LABEL(FILE,PREFIX,NUM)      \
 352 do{  if (PREFIX[0] == 'L' && PREFIX[1] == 'I')          \
 353     fprintf(FILE, "\tset %s%d,.+2\n", PREFIX, NUM);     \
 354   else                                                  \
 355     fprintf (FILE, "%s%d:\n", PREFIX, NUM);             \
 356 } while(0)
 357
 358 #define ASM_OUTPUT_DOUBLE(FILE, VALUE)                  \
 359   do { char dstr[30];                                   \
 360        REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr);    \
 361        fprintf (FILE, "\tdouble 0f%s\n", dstr);         \
 362      } while (0)
 363
 364 #define ASM_OUTPUT_FLOAT(FILE, VALUE)                   \
 365   do { char dstr[30];                                   \
 366        REAL_VALUE_TO_DECIMAL (VALUE, "%.9g", dstr);     \
 367        fprintf (FILE, "\tfloat 0f%s\n", dstr);          \
 368      } while (0)
 369
 370 #undef ASM_OUTPUT_LONG_DOUBLE
 371 #define ASM_OUTPUT_LONG_DOUBLE(FILE,VALUE)                              \
 372 do { long l[3];                                                         \
 373      REAL_VALUE_TO_TARGET_LONG_DOUBLE (VALUE, l);                       \
 374      fprintf (FILE, "\tlong 0x%x,0x%x,0x%x\n", l[0], l[1], l[2]);       \
 375    } while (0)
 376
 377 /* This is how to output an assembler line defining an `int' constant.  */
 378
 379 #define ASM_OUTPUT_INT(FILE,VALUE)  \
 380 ( fprintf (FILE, "\tlong "),                    \
 381   output_addr_const (FILE, (VALUE)),            \
 382   fprintf (FILE, "\n"))
 383
 384 /* Likewise for `char' and `short' constants.  */
 385
 386 #define ASM_OUTPUT_SHORT(FILE,VALUE)  \
 387 ( fprintf (FILE, "\tshort "),                   \
 388   output_addr_const (FILE, (VALUE)),            \
 389   fprintf (FILE, "\n"))
 390
 391 #define ASM_OUTPUT_CHAR(FILE,VALUE)  \
 392 ( fprintf (FILE, "\tbyte "),                    \
 393   output_addr_const (FILE, (VALUE)),            \
 394   fprintf (FILE, "\n"))
 395
 396 /* This is how to output an assembler line for a numeric constant byte.  */
 397
 398 #define ASM_OUTPUT_BYTE(FILE,VALUE)  \
 399   fprintf (FILE, "\tbyte 0x%x\n", (VALUE))
 400
 401 #define ASM_OUTPUT_ADDR_VEC_ELT(FILE, VALUE)  \
 402   fprintf (FILE, "\tlong L%d\n", VALUE)
 403
 404 #define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, VALUE, REL)  \
 405   fprintf (FILE, "\tshort L%d-L%d\n", VALUE, REL)
 406
 407 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 408   if ((LOG) == 1)                       \
 409     fprintf (FILE, "\tlalign 2\n");     \
 410   else if ((LOG) != 0)                  \
 411     abort ();
 412
 413 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
 414   fprintf (FILE, "\tspace %u\n", (SIZE))
 415
 416 #define ASM_OUTPUT_SOURCE_FILENAME(FILE, FILENAME)
 417 #define ASM_OUTPUT_SOURCE_LINE(FILE, LINENO)
 418
 419 #ifdef AS_BUG_FLOATING_CONSTANT
 420 #define PRINT_OPERAND_FLOAT(CODE,FILE,VALUE,INT)        \
 421  do { REAL_VALUE_TO_TARGET_SINGLE (VALUE, INT);         \
 422       fprintf (FILE, "&0x%x", INT); } while (0)
 423 #else
 424 #define PRINT_OPERAND_FLOAT(CODE,FILE,VALUE,INT)        \
 425  do { if (CODE == 'f')                                  \
 426         { char dstr[30];                                \
 427           REAL_VALUE_TO_DECIMAL (VALUE, "%.9g", dstr);  \
 428           fprintf (FILE, "&0f%s", dstr);                \
 429         }                                               \
 430       else                                              \
 431         {                                               \
 432           REAL_VALUE_TO_TARGET_SINGLE (VALUE, INT);     \
 433           fprintf (FILE, "&0x%x", INT); } } while (0)
 434 #endif /* AS_BUG_FLOATING_CONSTANT */
 435
 436 #define PRINT_OPERAND(FILE, X, CODE)  \
 437 { if (CODE == '.') fprintf (FILE, ".");                                 \
 438   else if (CODE == '#') fprintf (FILE, "&");                            \
 439   else if (CODE == '-') fprintf (FILE, "-(%%sp)");                      \
 440   else if (CODE == '+') fprintf (FILE, "(%%sp)+");                      \
 441   else if (CODE == '@') fprintf (FILE, "(%%sp)");                       \
 442   else if (CODE == '!') fprintf (FILE, "%%fpcr");                       \
 443   else if (CODE == '$') { if (TARGET_68040_ONLY) fprintf (FILE, "s"); } \
 444   else if (CODE == '&') { if (TARGET_68040_ONLY) fprintf (FILE, "d"); } \
 445   else if (CODE == '/')                                                 \
 446     fprintf (FILE, "%%");                                               \
 447   else if (GET_CODE (X) == REG)                                         \
 448     fprintf (FILE, "%s", reg_names[REGNO (X)]);                         \
 449   else if (GET_CODE (X) == MEM)                                         \
 450     output_address (XEXP (X, 0));                                       \
 451   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)      \
 452     { REAL_VALUE_TYPE r;  long l;                                       \
 453       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 454       PRINT_OPERAND_FLOAT (CODE, FILE, r, l); }                         \
 455   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode)      \
 456     { REAL_VALUE_TYPE r;  char dstr[30];                                \
 457       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 458       REAL_VALUE_TO_DECIMAL (r, "%.20g", dstr);                         \
 459       fprintf (FILE, "&0f%s", dstr); }                                  \
 460   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == XFmode)      \
 461     { REAL_VALUE_TYPE r;  char dstr[30];                                \
 462       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 463       REAL_VALUE_TO_DECIMAL (r, "%.20g", dstr);                         \
 464       fprintf (FILE, "&0f%s", dstr); }                                  \
 465   else { putc ('&', FILE); output_addr_const (FILE, X); }}
 466
 467 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
 468 { register rtx reg1, reg2, breg, ireg;                                  \
 469   register rtx addr = ADDR;                                             \
 470   rtx offset;                                                           \
 471   switch (GET_CODE (addr))                                              \
 472     {                                                                   \
 473     case REG:                                                           \
 474       fprintf (FILE, "(%s)", reg_names[REGNO (addr)]);                  \
 475       break;                                                            \
 476     case PRE_DEC:                                                       \
 477       fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);       \
 478       break;                                                            \
 479     case POST_INC:                                                      \
 480       fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);       \
 481       break;                                                            \
 482     case PLUS:                                                          \
 483       reg1 = 0; reg2 = 0;                                               \
 484       ireg = 0; breg = 0;                                               \
 485       offset = 0;                                                       \
 486       if (CONSTANT_ADDRESS_P (XEXP (addr, 0)))                          \
 487         {                                                               \
 488           offset = XEXP (addr, 0);                                      \
 489           addr = XEXP (addr, 1);                                        \
 490         }                                                               \
 491       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)))                     \
 492         {                                                               \
 493           offset = XEXP (addr, 1);                                      \
 494           addr = XEXP (addr, 0);                                        \
 495         }                                                               \
 496       if (GET_CODE (addr) != PLUS) ;                                    \
 497       else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND)                \
 498         {                                                               \
 499           reg1 = XEXP (addr, 0);                                        \
 500           addr = XEXP (addr, 1);                                        \
 501         }                                                               \
 502       else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND)                \
 503         {                                                               \
 504           reg1 = XEXP (addr, 1);                                        \
 505           addr = XEXP (addr, 0);                                        \
 506         }                                                               \
 507       else if (GET_CODE (XEXP (addr, 0)) == MULT)                       \
 508         {                                                               \
 509           reg1 = XEXP (addr, 0);                                        \
 510           addr = XEXP (addr, 1);                                        \
 511         }                                                               \
 512       else if (GET_CODE (XEXP (addr, 1)) == MULT)                       \
 513         {                                                               \
 514           reg1 = XEXP (addr, 1);                                        \
 515           addr = XEXP (addr, 0);                                        \
 516         }                                                               \
 517       else if (GET_CODE (XEXP (addr, 0)) == REG)                        \
 518         {                                                               \
 519           reg1 = XEXP (addr, 0);                                        \
 520           addr = XEXP (addr, 1);                                        \
 521         }                                                               \
 522       else if (GET_CODE (XEXP (addr, 1)) == REG)                        \
 523         {                                                               \
 524           reg1 = XEXP (addr, 1);                                        \
 525           addr = XEXP (addr, 0);                                        \
 526         }                                                               \
 527       if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT             \
 528           || GET_CODE (addr) == SIGN_EXTEND)                            \
 529         { if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; }     \
 530 /*  for OLD_INDEXING                                                    \
 531       else if (GET_CODE (addr) == PLUS)                                 \
 532         {                                                               \
 533           if (GET_CODE (XEXP (addr, 0)) == REG)                         \
 534             {                                                           \
 535               reg2 = XEXP (addr, 0);                                    \
 536               addr = XEXP (addr, 1);                                    \
 537             }                                                           \
 538           else if (GET_CODE (XEXP (addr, 1)) == REG)                    \
 539             {                                                           \
 540               reg2 = XEXP (addr, 1);                                    \
 541               addr = XEXP (addr, 0);                                    \
 542             }                                                           \
 543         }                                                               \
 544   */                                                                    \
 545       if (offset != 0) { if (addr != 0) abort (); addr = offset; }      \
 546       if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND                      \
 547                     || GET_CODE (reg1) == MULT))                        \
 548           || (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2))))         \
 549         { breg = reg2; ireg = reg1; }                                   \
 550       else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1)))         \
 551         { breg = reg1; ireg = reg2; }                                   \
 552       if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF)       \
 553         { int scale = 1;                                                \
 554           if (GET_CODE (ireg) == MULT)                                  \
 555             { scale = INTVAL (XEXP (ireg, 1));                          \
 556               ireg = XEXP (ireg, 0); }                                  \
 557           if (GET_CODE (ireg) == SIGN_EXTEND)                           \
 558             fprintf (FILE, "L%d-LI%d(%%pc,%s.w",                        \
 559                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 560                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 561                      reg_names[REGNO (XEXP (ireg, 0))]);                \
 562           else                                                          \
 563             fprintf (FILE, "L%d-LI%d(%%pc,%s.l",                        \
 564                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 565                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 566                      reg_names[REGNO (ireg)]);                          \
 567           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 568           putc (')', FILE);                                             \
 569           break; }                                                      \
 570       if (ireg != 0 || breg != 0)                                       \
 571         { int scale = 1;                                                \
 572           if (breg == 0)                                                \
 573             abort ();                                                   \
 574           if (addr != 0)                                                \
 575             output_addr_const (FILE, addr);                             \
 576           fprintf (FILE, "(%s", reg_names[REGNO (breg)]);               \
 577           if (ireg != 0)                                                \
 578             putc (',', FILE);                                           \
 579           if (ireg != 0 && GET_CODE (ireg) == MULT)                     \
 580             { scale = INTVAL (XEXP (ireg, 1));                          \
 581               ireg = XEXP (ireg, 0); }                                  \
 582           if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND)              \
 583             fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]);  \
 584           else if (ireg != 0)                                           \
 585             fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]);            \
 586           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 587           putc (')', FILE);                                             \
 588           break;                                                        \
 589         }                                                               \
 590       else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF)               \
 591         { fprintf (FILE, "L%d-LI%d(%%pc,%s.w)",                         \
 592                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 593                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 594                    reg_names[REGNO (reg1)]);                            \
 595           break; }                                                      \
 596     default:                                                            \
 597       if (GET_CODE (addr) == CONST_INT                                  \
 598           && INTVAL (addr) < 0x8000                                     \
 599           && INTVAL (addr) >= -0x8000)                                  \
 600         fprintf (FILE, "%d.w", INTVAL (addr));                          \
 601       else                                                              \
 602         output_addr_const (FILE, addr);                                 \
 603     }}
 604
 605 #define ASM_OUTPUT_ASCII(f, p, size)    \
 606 do { register int i;                    \
 607   int inside;                           \
 608   inside = FALSE;                       \
 609   for (i = 0; i < (size); i++) {        \
 610     if (i % 8 == 0) {                   \
 611       if (i != 0) {                     \
 612         if (inside)                     \
 613           putc('"', (f));               \
 614         putc('\n', (f));                \
 615         inside = FALSE;                 \
 616       }                                 \
 617       fprintf((f), "\t%s ", ASCII_DATA_ASM_OP); \
 618     }                                   \
 619     if ((p)[i] < 32 || (p)[i] == '\\' || (p)[i] == '"' || (p)[i] == 127) {      \
 620       if (inside) {                     \
 621         putc('"', (f));                 \
 622         inside = FALSE;                 \
 623       }                                 \
 624       if (i % 8 != 0)                   \
 625         putc(',', (f));                 \
 626       fprintf((f), "%d", (p)[i]);       \
 627     } else {                            \
 628       if (!inside) {                    \
 629         if (i % 8 != 0)                 \
 630           putc(',', (f));               \
 631         putc('"', (f));                 \
 632         inside = TRUE;                  \
 633       }                                 \
 634       putc((p)[i], (f));                \
 635     }                                   \
 636   }                                     \
 637   if (inside)                           \
 638     putc('"', (f));                     \
 639   putc('\n', (f));                      \
 640 } while (0)
 641
 642 /* Translate Motorola opcodes such as `jbeq'
 643    into SGS opcodes such as `beq.w'.
 644    Delete the `e' in `move...' and `fmove'.
 645    Change `ftst' to `ftest'.  */
 646
 647 #define ASM_OUTPUT_OPCODE(FILE, PTR)                    \
 648 { if ((PTR)[0] == 'j' && (PTR)[1] == 'b')               \
 649     { ++(PTR);                                          \
 650       while (*(PTR) != ' ')                             \
 651         { putc (*(PTR), (FILE)); ++(PTR); }             \
 652       fprintf ((FILE), ".w"); }                         \
 653   else if ((PTR)[0] == 'f')                             \
 654     {                                                   \
 655       if (!strncmp ((PTR), "fmove", 5))                 \
 656         { fprintf ((FILE), "fmov"); (PTR) += 5; }       \
 657       else if (!strncmp ((PTR), "ftst", 4))             \
 658         { fprintf ((FILE), "ftest"); (PTR) += 4; }      \
 659     }                                                   \
 660   else if ((PTR)[0] == 'm' && (PTR)[1] == 'o'           \
 661            && (PTR)[2] == 'v' && (PTR)[3] == 'e')       \
 662     { fprintf ((FILE), "mov"); (PTR) += 4; }            \
 663 }
 664
 665 /* Prevent output of `gcc_compiled.:'.  */
 666
 667 #define ASM_IDENTIFY_GCC(FILE)
 668
 669 #else /* not HPUX_ASM */
 670
 671 #undef FUNCTION_PROFILER
 672
 673 /* HP-UX needs the call to mcount before the link instruction.
 674    Copy the return address onto the stack before the call to fake it out.  */
 675 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 676   fprintf (FILE, \
 677            "\tmovel a6@(4),sp@-\n\tmovl #LP%d,a0\n\tjsr mcount\n\taddqw #4,sp\n", \
 678            (LABEL_NO));
 679
 680 #endif /* not HPUX_ASM */
 681 /* In m68k svr4, a symbol_ref rtx can be a valid PIC operand if it is an
 682    operand of a function call. */
 683 #undef LEGITIMATE_PIC_OPERAND_P
 684 #define LEGITIMATE_PIC_OPERAND_P(X) \
 685   (! symbolic_operand (X, VOIDmode) \
 686    || ((GET_CODE(X) == SYMBOL_REF) && SYMBOL_REF_FLAG(X)))
 687
 688 /* hpux8 and later have C++ compatable include files, so do not
 689    pretend they are `extern "C"'.  */
 690 #define NO_IMPLICIT_EXTERN_C