gcc/config/m68k/news.h

   1 /* Definitions of target machine for GNU compiler.  SONY NEWS-OS 4 version.
   2    Copyright (C) 1987, 89, 93, 94, 96-98, 1999 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, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #ifndef USE_GAS
  22 /* This controls conditionals in m68k.h.  */
  23 #define MOTOROLA                /* Use Motorola syntax rather than "MIT" */
  24 #define SGS_NO_LI               /* Suppress jump table label usage */
  25 #endif
  26
  27 #define NO_DOLLAR_IN_LABEL
  28 #define NO_DOT_IN_LABEL
  29
  30 #include "m68k/m68k.h"
  31
  32 /* See m68k.h.  7 means 68020 with 68881.  */
  33
  34 #define TARGET_DEFAULT (MASK_BITFIELD|MASK_68881|MASK_68020)
  35
  36 /* Define __HAVE_68881__ in preprocessor, unless -msoft-float is specified.
  37    This will control the use of inline 68881 insns in certain macros.  */
  38
  39 #define CPP_SPEC "%{!msoft-float:-D__HAVE_68881__}"
  40
  41 /* Names to predefine in the preprocessor for this target machine.  */
  42 /* These are the ones defined by Sony, plus mc68000 for uniformity with
  43    GCC on other 68000 systems.  */
  44
  45 #ifdef MOTOROLA
  46 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dnews700 -D__motorola__ -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  47 #else
  48 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dnews700 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  49 #endif
  50
  51 /* These conditionals tested for different submodels,
  52    but they were incorrect since they tested the host rather than the target.
  53    The choice of model shouldn't actually matter.  */
  54
  55 #if 0
  56 #ifdef news800
  57 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dnews800 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  58 #endif
  59 #ifdef news900
  60 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dnews900 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  61 #endif
  62 #ifdef news1500
  63 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dmc68030 -Dnews1500 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  64 #endif
  65 #ifdef news1700
  66 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dmc68030 -Dnews1700 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  67 #endif
  68 #ifdef news1800
  69 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dmc68030 -Dnews1800 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  70 #endif
  71 #ifdef news1900
  72 #define CPP_PREDEFINES "-Dunix -Dbsd43 -Dsony -Dsony_news -Dmc68000 -Dmc68020 -Dmc68030 -Dnews1900 -Asystem(unix) -Asystem(bsd) -Acpu(m68k) -Amachine(m68k)"
  73 #endif
  74 #endif
  75
  76 /* Link with libg.a when debugging, for dbx's sake.  */
  77
  78 #define LIB_SPEC "%{g:-lg} %{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p} "
  79
  80 /* This is BSD, so it wants DBX format.  */
  81
  82 #define DBX_DEBUGGING_INFO
  83
  84 #if 0
  85 /* This is to be compatible with types.h.
  86    It was found to be necessary with Newsos 3.  */
  87
  88 #define SIZE_TYPE "long int"
  89 #endif
  90 \f
  91 /* Override parts of m68k.h to fit Sony's assembler syntax.  */
  92
  93 #undef BIGGEST_ALIGNMENT
  94 #undef CALL_USED_REGISTERS
  95 #undef FUNCTION_VALUE
  96 #undef LIBCALL_VALUE
  97 #undef FUNCTION_PROFILER
  98
  99 #ifdef MOTOROLA
 100 #undef FUNCTION_PROLOGUE
 101 #undef FUNCTION_EPILOGUE
 102 #undef REGISTER_NAMES
 103 #undef ASM_OUTPUT_REG_PUSH
 104 #undef ASM_OUTPUT_REG_POP
 105 #undef ASM_OUTPUT_DOUBLE
 106 #undef ASM_OUTPUT_SKIP
 107 #undef ASM_FORMAT_PRIVATE_NAME
 108 #endif
 109
 110 #undef ASM_OUTPUT_ALIGN
 111
 112 /* There is no point aligning anything to a rounder boundary than this.  */
 113 #define BIGGEST_ALIGNMENT 32
 114
 115 /* A bitfield declared as `int' forces `int' alignment for the struct.  */
 116 #define PCC_BITFIELD_TYPE_MATTERS 1
 117
 118 /* NEWS makes d2, d3, fp2 and fp3 unsaved registers, unlike the Sun system.  */
 119
 120 #define CALL_USED_REGISTERS \
 121  {1, 1, 1, 1, 0, 0, 0, 0, \
 122   1, 1, 0, 0, 0, 0, 0, 1, \
 123   1, 1, 1, 1, 0, 0, 0, 0}
 124
 125 /* NEWS returns floats and doubles in fp0, not d0/d1.  */
 126
 127 #define FUNCTION_VALUE(VALTYPE,FUNC) LIBCALL_VALUE (TYPE_MODE (VALTYPE))
 128
 129 #define LIBCALL_VALUE(MODE)                                     \
 130  gen_rtx_REG ((MODE),                                           \
 131               ((TARGET_68881                                    \
 132                 && ((MODE) == SFmode || (MODE) == DFmode        \
 133                     || (MODE) == XFmode))                       \
 134                ? 16 : 0))
 135
 136 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 137   fprintf (FILE, "\t.align %d\n", (LOG))
 138 \f
 139 #ifdef MOTOROLA
 140
 141 /* Don't try to define `gcc_compiled.' since the assembler does not
 142    accept symbols with periods.  This is no real loss since GDB only
 143    really needs it for parms passed in registers.  */
 144 #define ASM_IDENTIFY_GCC(FILE)
 145
 146 #define FUNCTION_PROLOGUE(FILE, SIZE)     \
 147 { register int regno;                                           \
 148   register int mask = 0;                                        \
 149   extern char call_used_regs[];                                 \
 150   int fsize = ((SIZE) + 3) & -4;                                \
 151   if (frame_pointer_needed)                                     \
 152     { if (fsize < 0x8000)                                       \
 153         fprintf (FILE, "\tlink fp,#%d\n", -fsize);              \
 154       else if (TARGET_68020)                                    \
 155         fprintf (FILE, "\tlink.l fp,#%d\n", -fsize);            \
 156       else                                                      \
 157         fprintf (FILE, "\tlink fp,#0\n\tsub.l #%d,sp\n", fsize);\
 158     }                                                           \
 159   else if (fsize)                                               \
 160     {                                                           \
 161       int amt = fsize + 4;                                      \
 162       /* Adding negative number is faster on the 68040.  */     \
 163       if (fsize + 4 < 0x8000)                                   \
 164         asm_fprintf (FILE, "\tadd.w %0I%d,%Rsp\n", - amt);      \
 165       else                                                      \
 166         asm_fprintf (FILE, "\tadd.l %0I%d,%Rsp\n", - amt);      \
 167     }                                                           \
 168   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 169     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 170        mask |= 1 << (regno - 16);                               \
 171   if (mask != 0)                                                \
 172     fprintf (FILE, "\tfmovem.x #0x%x,-(sp)\n", mask & 0xff);    \
 173   mask = 0;                                                     \
 174   for (regno = 0; regno < 16; regno++)                          \
 175     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 176        mask |= 1 << (15 - regno);                               \
 177   if (frame_pointer_needed)                                     \
 178     mask &= ~ (1 << (15-FRAME_POINTER_REGNUM));                 \
 179   if (exact_log2 (mask) >= 0)                                   \
 180     fprintf (FILE, "\tmove.l %s,-(sp)\n", reg_names[15 - exact_log2 (mask)]);  \
 181   else if (mask) fprintf (FILE, "\tmovem.l #0x%x,-(sp)\n", mask); }
 182
 183 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 184    fprintf (FILE, "\tmove.l #LP%d,d0\n\tjsr mcount\n", (LABEL_NO));
 185
 186 #define FUNCTION_EPILOGUE(FILE, SIZE) \
 187 { register int regno;                                           \
 188   register int mask, fmask;                                     \
 189   register int nregs;                                           \
 190   int offset, foffset;                                          \
 191   extern char call_used_regs[];                                 \
 192   int fsize = ((SIZE) + 3) & -4;                                \
 193   int big = 0;                                                  \
 194   nregs = 0;  fmask = 0;                                        \
 195   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 196     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 197       { nregs++; fmask |= 1 << (23 - regno); }                  \
 198   foffset = nregs * 12;                                         \
 199   nregs = 0;  mask = 0;                                         \
 200   if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
 201   for (regno = 0; regno < 16; regno++)                          \
 202     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 203       { nregs++; mask |= 1 << regno; }                          \
 204   offset = foffset + nregs * 4;                                 \
 205   if (offset + fsize >= 0x8000                                  \
 206       && frame_pointer_needed                                   \
 207       && (mask || fmask))                                       \
 208     { fprintf (FILE, "\tmove.l #%d,a0\n", -fsize);              \
 209       fsize = 0, big = 1; }                                     \
 210   if (exact_log2 (mask) >= 0) {                                 \
 211     if (big)                                                    \
 212       fprintf (FILE, "\tmove.l (-%d,fp,a0.l),%s\n",             \
 213                offset + fsize, reg_names[exact_log2 (mask)]);   \
 214     else if (! frame_pointer_needed)                            \
 215       fprintf (FILE, "\tmove.l (sp)+,%s\n",                     \
 216                reg_names[exact_log2 (mask)]);                   \
 217     else                                                        \
 218       fprintf (FILE, "\tmove.l (-%d,fp),%s\n",                  \
 219                offset + fsize, reg_names[exact_log2 (mask)]); } \
 220   else if (mask) {                                              \
 221     if (big)                                                    \
 222       fprintf (FILE, "\tmovem.l (-%d,fp,a0.l),#0x%x\n",         \
 223                offset + fsize, mask);                           \
 224     else if (! frame_pointer_needed)                            \
 225       fprintf (FILE, "\tmovem.l (sp)+,#0x%x\n", mask);          \
 226     else                                                        \
 227       fprintf (FILE, "\tmovem.l (-%d,fp),#0x%x\n",              \
 228                offset + fsize, mask); }                         \
 229   if (fmask) {                                                  \
 230     if (big)                                                    \
 231       fprintf (FILE, "\tfmovem.x (-%d,fp,a0.l),#0x%x\n",        \
 232                foffset + fsize, fmask);                         \
 233     else if (! frame_pointer_needed)                            \
 234       fprintf (FILE, "\tfmovem.x (sp)+,#0x%x\n", fmask);        \
 235     else                                                        \
 236       fprintf (FILE, "\tfmovem.x (-%d,fp),#0x%x\n",             \
 237                foffset + fsize, fmask); }                       \
 238   if (frame_pointer_needed)                                     \
 239     fprintf (FILE, "\tunlk fp\n");                              \
 240   else if (fsize)                                               \
 241     {                                                           \
 242       if (fsize + 4 < 0x8000)                                   \
 243         fprintf (FILE, "\tadd.w #%d,sp\n", fsize + 4);          \
 244       else                                                      \
 245         fprintf (FILE, "\tadd.l #%d,sp\n", fsize + 4);          \
 246     }                                                           \
 247   if (current_function_pops_args)                               \
 248     fprintf (FILE, "\trtd #%d\n", current_function_pops_args);  \
 249   else fprintf (FILE, "\trts\n"); }
 250
 251 /* Difference from m68k.h is in `fp' instead of `a6'.  */
 252
 253 #define REGISTER_NAMES \
 254 {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",        \
 255  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",        \
 256  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7"}
 257
 258 /* This is how to output an insn to push a register on the stack.
 259    It need not be very fast code.  */
 260
 261 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
 262   fprintf (FILE, "\tmove.l %s,-(sp)\n", reg_names[REGNO])
 263
 264 /* This is how to output an insn to pop a register from the stack.
 265    It need not be very fast code.  */
 266
 267 #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
 268   fprintf (FILE, "\tmove.l (sp)+,%s\n", reg_names[REGNO])
 269
 270 #define ASM_OUTPUT_DOUBLE(FILE,VALUE)  \
 271 do { char dstr[30];                                     \
 272      REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr);    \
 273      fprintf (FILE, "\t.double 0d%s\n", dstr);          \
 274    } while (0)
 275
 276 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
 277   fprintf (FILE, "\t.space %u\n", (SIZE))
 278
 279 #if 0
 280 /* The NEWS assembler in version 3.4 complains about fmove.d, but this
 281    macro proved not to work right.  3.4 is old, so forget about it. */
 282 #define ASM_OUTPUT_OPCODE(FILE, STRING) \
 283 {                                               \
 284   if (!strncmp (STRING, "fmove.d", 7)           \
 285       && CONSTANT_P (operands[1]))              \
 286     {                                           \
 287       fprintf (FILE, "fmove.x");                \
 288       STRING += 7;                              \
 289     }                                           \
 290 }
 291 #endif
 292
 293 /* Store in OUTPUT a string (made with alloca) containing
 294    an assembler-name for a local static variable named NAME.
 295    LABELNO is an integer which is different for each call.  */
 296
 297 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 298 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 13),    \
 299   sprintf ((OUTPUT), "%s$$$%d", (NAME), (LABELNO)))
 300
 301 /* Output a float value (represented as a C double) as an immediate operand.
 302    This macro is a 68k-specific macro.  */
 303
 304 #undef ASM_OUTPUT_FLOAT_OPERAND
 305 #define ASM_OUTPUT_FLOAT_OPERAND(CODE,FILE,VALUE)                       \
 306  do {                                                                   \
 307       if (CODE == 'f')                                                  \
 308         {                                                               \
 309           char dstr[30];                                                \
 310           REAL_VALUE_TO_DECIMAL (VALUE, "%.9e", dstr);                  \
 311           if (REAL_VALUE_ISINF (VALUE) || REAL_VALUE_ISNAN (VALUE))     \
 312             {                                                           \
 313               if (REAL_VALUE_NEGATIVE (VALUE))                          \
 314                 fprintf (FILE, "#0f-99e999");                           \
 315               else                                                      \
 316                 fprintf (FILE, "#0f99e999");                            \
 317             }                                                           \
 318           else if (REAL_VALUE_MINUS_ZERO (VALUE))                       \
 319             fprintf (FILE, "#0f-0.0");                                  \
 320           else                                                          \
 321             fprintf (FILE, "#0f%s", dstr);                              \
 322         }                                                               \
 323       else                                                              \
 324         {                                                               \
 325           long l;                                                       \
 326           REAL_VALUE_TO_TARGET_SINGLE (VALUE, l);                       \
 327           fprintf (FILE, "#0x%lx", l);                                  \
 328         }                                                               \
 329      } while (0)
 330
 331 /* Output a double value (represented as a C double) as an immediate operand.
 332    This macro is a 68k-specific macro.  */
 333 #undef ASM_OUTPUT_DOUBLE_OPERAND
 334 #define ASM_OUTPUT_DOUBLE_OPERAND(FILE,VALUE)                           \
 335  do { char dstr[30];                                                    \
 336       REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr );                    \
 337       if (REAL_VALUE_ISINF (VALUE) || REAL_VALUE_ISNAN (VALUE))         \
 338         {                                                               \
 339         if (REAL_VALUE_NEGATIVE (VALUE))                                \
 340           fprintf (FILE, "#0d-99e999");                                 \
 341         else                                                            \
 342           fprintf (FILE, "#0d99e999");                                  \
 343         }                                                               \
 344       else if (REAL_VALUE_MINUS_ZERO (VALUE))                           \
 345           fprintf (FILE, "#0d-0.0");                                    \
 346       else                                                              \
 347           fprintf (FILE, "#0d%s", dstr);                                \
 348     } while (0)
 349
 350 /* Note, long double immediate operands are not actually
 351    generated by m68k.md.  */
 352 #undef ASM_OUTPUT_LONG_DOUBLE_OPERAND
 353 #define ASM_OUTPUT_LONG_DOUBLE_OPERAND(FILE,VALUE)                      \
 354  do { char dstr[30];                                                    \
 355       REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr);                     \
 356       asm_fprintf (FILE, "%I0r%s", dstr);                               \
 357     } while (0)
 358
 359 #if 0
 360 #undef PRINT_OPERAND
 361 #define PRINT_OPERAND(FILE, X, CODE)  \
 362 { if (CODE == '.') fprintf (FILE, ".");                                 \
 363   else if (CODE == '#') fprintf (FILE, "#");                            \
 364   else if (CODE == '-') fprintf (FILE, "-(sp)");                        \
 365   else if (CODE == '+') fprintf (FILE, "(sp)+");                        \
 366   else if (CODE == '@') fprintf (FILE, "(sp)");                         \
 367   else if (CODE == '!') fprintf (FILE, "fpcr");                         \
 368   else if (CODE == '$') {if (TARGET_68040_ONLY) fprintf (FILE, "s");}   \
 369   else if (CODE == '&') {if (TARGET_68040_ONLY) fprintf (FILE, "d");}   \
 370   else if (CODE == '/')                                                 \
 371     ;                                                                   \
 372   else if (GET_CODE (X) == REG)                                         \
 373     fprintf (FILE, "%s", reg_names[REGNO (X)]);                         \
 374   else if (GET_CODE (X) == MEM)                                         \
 375     output_address (XEXP (X, 0));                                       \
 376   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)      \
 377     { REAL_VALUE_TYPE r;                                                \
 378       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 379       if (CODE == 'f')                                                  \
 380         { char dstr[30];                                                \
 381           REAL_VALUE_TO_DECIMAL (r, "%.9e", dstr);                      \
 382           if (REAL_VALUE_ISINF (r) || REAL_VALUE_ISNAN (r)) {           \
 383             if (REAL_VALUE_NEGATIVE (r))                                \
 384               fprintf (FILE, "#0f-99e999");                             \
 385             else                                                        \
 386               fprintf (FILE, "#0f99e999"); }                            \
 387           else if (REAL_VALUE_MINUS_ZERO (r))                           \
 388             fprintf (FILE, "#0f-0.0");                                  \
 389           else                                                          \
 390             fprintf (FILE, "#0f%s", dstr);                              \
 391         }                                                               \
 392       else                                                              \
 393         { long l;                                                       \
 394           REAL_VALUE_TO_TARGET_SINGLE (r, l);                           \
 395           fprintf (FILE, "#0x%x", l);                                   \
 396         }}                                                              \
 397   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == XFmode)      \
 398     { REAL_VALUE_TYPE r;                                                \
 399       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 400       ASM_OUTPUT_LONG_DOUBLE_OPERAND (FILE, r); }                       \
 401   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode)      \
 402     { REAL_VALUE_TYPE r; char dstr[30];                                 \
 403       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 404       REAL_VALUE_TO_DECIMAL (r, "%.20e", dstr );                        \
 405       if (REAL_VALUE_ISINF (r) || REAL_VALUE_ISNAN (r)) {               \
 406         if (REAL_VALUE_NEGATIVE (r))                                    \
 407           fprintf (FILE, "#0d-99e999");                                 \
 408         else                                                            \
 409           fprintf (FILE, "#0d99e999"); }                                \
 410       else if (REAL_VALUE_MINUS_ZERO (r))                               \
 411           fprintf (FILE, "#0d-0.0");                                    \
 412       else                                                              \
 413           fprintf (FILE, "#0d%s", dstr); }                              \
 414   else if (CODE == 'b') output_addr_const (FILE, X);                    \
 415   else { putc ('#', FILE); output_addr_const (FILE, X); }}
 416 #endif
 417
 418 #undef PRINT_OPERAND_ADDRESS
 419 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
 420 { register rtx reg1, reg2, breg, ireg;                                  \
 421   register rtx addr = ADDR;                                             \
 422   rtx offset;                                                           \
 423   switch (GET_CODE (addr))                                              \
 424     {                                                                   \
 425     case REG:                                                           \
 426       fprintf (FILE, "(%s)", reg_names[REGNO (addr)]);                  \
 427       break;                                                            \
 428     case PRE_DEC:                                                       \
 429       fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);       \
 430       break;                                                            \
 431     case POST_INC:                                                      \
 432       fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);       \
 433       break;                                                            \
 434     case PLUS:                                                          \
 435       reg1 = 0; reg2 = 0;                                               \
 436       ireg = 0; breg = 0;                                               \
 437       offset = 0;                                                       \
 438       if (CONSTANT_ADDRESS_P (XEXP (addr, 0)))                          \
 439         {                                                               \
 440           offset = XEXP (addr, 0);                                      \
 441           addr = XEXP (addr, 1);                                        \
 442         }                                                               \
 443       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)))                     \
 444         {                                                               \
 445           offset = XEXP (addr, 1);                                      \
 446           addr = XEXP (addr, 0);                                        \
 447         }                                                               \
 448       if (GET_CODE (addr) != PLUS) ;                                    \
 449       else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND)                \
 450         {                                                               \
 451           reg1 = XEXP (addr, 0);                                        \
 452           addr = XEXP (addr, 1);                                        \
 453         }                                                               \
 454       else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND)                \
 455         {                                                               \
 456           reg1 = XEXP (addr, 1);                                        \
 457           addr = XEXP (addr, 0);                                        \
 458         }                                                               \
 459       else if (GET_CODE (XEXP (addr, 0)) == MULT)                       \
 460         {                                                               \
 461           reg1 = XEXP (addr, 0);                                        \
 462           addr = XEXP (addr, 1);                                        \
 463         }                                                               \
 464       else if (GET_CODE (XEXP (addr, 1)) == MULT)                       \
 465         {                                                               \
 466           reg1 = XEXP (addr, 1);                                        \
 467           addr = XEXP (addr, 0);                                        \
 468         }                                                               \
 469       else if (GET_CODE (XEXP (addr, 0)) == REG)                        \
 470         {                                                               \
 471           reg1 = XEXP (addr, 0);                                        \
 472           addr = XEXP (addr, 1);                                        \
 473         }                                                               \
 474       else if (GET_CODE (XEXP (addr, 1)) == REG)                        \
 475         {                                                               \
 476           reg1 = XEXP (addr, 1);                                        \
 477           addr = XEXP (addr, 0);                                        \
 478         }                                                               \
 479       if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT             \
 480           || GET_CODE (addr) == SIGN_EXTEND)                            \
 481         { if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; }     \
 482       if (offset != 0) { if (addr != 0) abort (); addr = offset; }      \
 483       if ((reg1 && (GET_CODE (reg1) == SIGN_EXTEND                      \
 484                     || GET_CODE (reg1) == MULT))                        \
 485           || (reg2 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg2))))         \
 486         { breg = reg2; ireg = reg1; }                                   \
 487       else if (reg1 != 0 && REGNO_OK_FOR_BASE_P (REGNO (reg1)))         \
 488         { breg = reg1; ireg = reg2; }                                   \
 489       if (ireg != 0 && breg == 0 && GET_CODE (addr) == LABEL_REF)       \
 490         { int scale = 1;                                                \
 491           if (GET_CODE (ireg) == MULT)                                  \
 492             { scale = INTVAL (XEXP (ireg, 1));                          \
 493               ireg = XEXP (ireg, 0); }                                  \
 494           if (GET_CODE (ireg) == SIGN_EXTEND)                           \
 495             fprintf (FILE, "(L%d.b,pc,%s.w",                            \
 496                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 497                      reg_names[REGNO (XEXP (ireg, 0))]);                \
 498           else                                                          \
 499             fprintf (FILE, "(L%d.b,pc,%s.l",                            \
 500                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 501                      reg_names[REGNO (ireg)]);                          \
 502           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 503           putc (')', FILE);                                             \
 504           break; }                                                      \
 505       if (breg != 0 && ireg == 0 && GET_CODE (addr) == LABEL_REF)       \
 506         { fprintf (FILE, "(L%d.b,pc,%s.l",                              \
 507                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 508                    reg_names[REGNO (breg)]);                            \
 509           putc (')', FILE);                                             \
 510           break; }                                                      \
 511       if (ireg != 0 || breg != 0)                                       \
 512         { int scale = 1;                                                \
 513           if (breg == 0)                                                \
 514             abort ();                                                   \
 515           if (addr && GET_CODE (addr) == LABEL_REF) abort ();           \
 516           fprintf (FILE, "(");                                          \
 517           if (addr != 0) {                                              \
 518             output_addr_const (FILE, addr);                             \
 519             putc (',', FILE); }                                         \
 520           fprintf (FILE, "%s", reg_names[REGNO (breg)]);                \
 521           if (ireg != 0)                                                \
 522             putc (',', FILE);                                           \
 523           if (ireg != 0 && GET_CODE (ireg) == MULT)                     \
 524             { scale = INTVAL (XEXP (ireg, 1));                          \
 525               ireg = XEXP (ireg, 0); }                                  \
 526           if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND)              \
 527             fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]);  \
 528           else if (ireg != 0)                                           \
 529             fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]);            \
 530           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 531           putc (')', FILE);                                             \
 532           break;                                                        \
 533         }                                                               \
 534       else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF)               \
 535         { fprintf (FILE, "(L%d.b,pc,%s.l)",                             \
 536                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 537                    reg_names[REGNO (reg1)]);                            \
 538           break; }                                                      \
 539     default:                                                            \
 540       if (GET_CODE (addr) == CONST_INT                                  \
 541           && INTVAL (addr) < 0x8000                                     \
 542           && INTVAL (addr) >= -0x8000)                                  \
 543         fprintf (FILE, "%d.w", INTVAL (addr));                          \
 544       else                                                              \
 545         output_addr_const (FILE, addr);                                 \
 546     }}
 547
 548 #else /* Using GAS, which uses the MIT assembler syntax, like a Sun.  */
 549
 550 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 551    fprintf (FILE, "\tmovl #LP%d,d0\n\tjsr mcount\n", (LABEL_NO));
 552
 553 #endif /* MOTOROLA */