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, 1997 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 || (MODE) == XFmode)) \
 133            ? 16 : 0))
 134
 135 #define ASM_OUTPUT_ALIGN(FILE,LOG)      \
 136   fprintf (FILE, "\t.align %d\n", (LOG))
 137 \f
 138 #ifdef MOTOROLA
 139
 140 /* Don't try to define `gcc_compiled.' since the assembler does not
 141    accept symbols with periods.  This is no real loss since GDB only
 142    really needs it for parms passed in registers.  */
 143 #define ASM_IDENTIFY_GCC(FILE)
 144
 145 #define FUNCTION_PROLOGUE(FILE, SIZE)     \
 146 { register int regno;                                           \
 147   register int mask = 0;                                        \
 148   extern char call_used_regs[];                                 \
 149   int fsize = ((SIZE) + 3) & -4;                                \
 150   if (frame_pointer_needed)                                     \
 151     { if (fsize < 0x8000)                                       \
 152         fprintf (FILE, "\tlink fp,#%d\n", -fsize);              \
 153       else if (TARGET_68020)                                    \
 154         fprintf (FILE, "\tlink.l fp,#%d\n", -fsize);            \
 155       else                                                      \
 156         fprintf (FILE, "\tlink fp,#0\n\tsub.l #%d,sp\n", fsize);\
 157     }                                                           \
 158   else if (fsize)                                               \
 159     {                                                           \
 160       int amt = fsize + 4;                                      \
 161       /* Adding negative number is faster on the 68040.  */     \
 162       if (fsize + 4 < 0x8000)                                   \
 163         asm_fprintf (FILE, "\tadd.w %0I%d,%Rsp\n", - amt);      \
 164       else                                                      \
 165         asm_fprintf (FILE, "\tadd.l %0I%d,%Rsp\n", - amt);      \
 166     }                                                           \
 167   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 168     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 169        mask |= 1 << (regno - 16);                               \
 170   if (mask != 0)                                                \
 171     fprintf (FILE, "\tfmovem.x #0x%x,-(sp)\n", mask & 0xff);    \
 172   mask = 0;                                                     \
 173   for (regno = 0; regno < 16; regno++)                          \
 174     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 175        mask |= 1 << (15 - regno);                               \
 176   if (frame_pointer_needed)                                     \
 177     mask &= ~ (1 << (15-FRAME_POINTER_REGNUM));                 \
 178   if (exact_log2 (mask) >= 0)                                   \
 179     fprintf (FILE, "\tmove.l %s,-(sp)\n", reg_names[15 - exact_log2 (mask)]);  \
 180   else if (mask) fprintf (FILE, "\tmovem.l #0x%x,-(sp)\n", mask); }
 181
 182 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 183    fprintf (FILE, "\tmove.l #LP%d,d0\n\tjsr mcount\n", (LABEL_NO));
 184
 185 #define FUNCTION_EPILOGUE(FILE, SIZE) \
 186 { register int regno;                                           \
 187   register int mask, fmask;                                     \
 188   register int nregs;                                           \
 189   int offset, foffset;                                          \
 190   extern char call_used_regs[];                                 \
 191   int fsize = ((SIZE) + 3) & -4;                                \
 192   int big = 0;                                                  \
 193   nregs = 0;  fmask = 0;                                        \
 194   for (regno = 16; regno < FIRST_PSEUDO_REGISTER; regno++)      \
 195     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 196       { nregs++; fmask |= 1 << (23 - regno); }                  \
 197   foffset = nregs * 12;                                         \
 198   nregs = 0;  mask = 0;                                         \
 199   if (frame_pointer_needed) regs_ever_live[FRAME_POINTER_REGNUM] = 0; \
 200   for (regno = 0; regno < 16; regno++)                          \
 201     if (regs_ever_live[regno] && ! call_used_regs[regno])       \
 202       { nregs++; mask |= 1 << regno; }                          \
 203   offset = foffset + nregs * 4;                                 \
 204   if (offset + fsize >= 0x8000                                  \
 205       && frame_pointer_needed                                   \
 206       && (mask || fmask))                                       \
 207     { fprintf (FILE, "\tmove.l #%d,a0\n", -fsize);              \
 208       fsize = 0, big = 1; }                                     \
 209   if (exact_log2 (mask) >= 0) {                                 \
 210     if (big)                                                    \
 211       fprintf (FILE, "\tmove.l (-%d,fp,a0.l),%s\n",             \
 212                offset + fsize, reg_names[exact_log2 (mask)]);   \
 213     else if (! frame_pointer_needed)                            \
 214       fprintf (FILE, "\tmove.l (sp)+,%s\n",                     \
 215                reg_names[exact_log2 (mask)]);                   \
 216     else                                                        \
 217       fprintf (FILE, "\tmove.l (-%d,fp),%s\n",                  \
 218                offset + fsize, reg_names[exact_log2 (mask)]); } \
 219   else if (mask) {                                              \
 220     if (big)                                                    \
 221       fprintf (FILE, "\tmovem.l (-%d,fp,a0.l),#0x%x\n",         \
 222                offset + fsize, mask);                           \
 223     else if (! frame_pointer_needed)                            \
 224       fprintf (FILE, "\tmovem.l (sp)+,#0x%x\n", mask);          \
 225     else                                                        \
 226       fprintf (FILE, "\tmovem.l (-%d,fp),#0x%x\n",              \
 227                offset + fsize, mask); }                         \
 228   if (fmask) {                                                  \
 229     if (big)                                                    \
 230       fprintf (FILE, "\tfmovem.x (-%d,fp,a0.l),#0x%x\n",        \
 231                foffset + fsize, fmask);                         \
 232     else if (! frame_pointer_needed)                            \
 233       fprintf (FILE, "\tfmovem.x (sp)+,#0x%x\n", fmask);        \
 234     else                                                        \
 235       fprintf (FILE, "\tfmovem.x (-%d,fp),#0x%x\n",             \
 236                foffset + fsize, fmask); }                       \
 237   if (frame_pointer_needed)                                     \
 238     fprintf (FILE, "\tunlk fp\n");                              \
 239   else if (fsize)                                               \
 240     {                                                           \
 241       if (fsize + 4 < 0x8000)                                   \
 242         fprintf (FILE, "\tadd.w #%d,sp\n", fsize + 4);          \
 243       else                                                      \
 244         fprintf (FILE, "\tadd.l #%d,sp\n", fsize + 4);          \
 245     }                                                           \
 246   if (current_function_pops_args)                               \
 247     fprintf (FILE, "\trtd #%d\n", current_function_pops_args);  \
 248   else fprintf (FILE, "\trts\n"); }
 249
 250 /* Difference from m68k.h is in `fp' instead of `a6'.  */
 251
 252 #define REGISTER_NAMES \
 253 {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7",        \
 254  "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp",        \
 255  "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7"}
 256
 257 /* This is how to output an insn to push a register on the stack.
 258    It need not be very fast code.  */
 259
 260 #define ASM_OUTPUT_REG_PUSH(FILE,REGNO)  \
 261   fprintf (FILE, "\tmove.l %s,-(sp)\n", reg_names[REGNO])
 262
 263 /* This is how to output an insn to pop a register from the stack.
 264    It need not be very fast code.  */
 265
 266 #define ASM_OUTPUT_REG_POP(FILE,REGNO)  \
 267   fprintf (FILE, "\tmove.l (sp)+,%s\n", reg_names[REGNO])
 268
 269 #define ASM_OUTPUT_DOUBLE(FILE,VALUE)  \
 270 do { char dstr[30];                                     \
 271      REAL_VALUE_TO_DECIMAL ((VALUE), "%.20e", dstr);    \
 272      fprintf (FILE, "\t.double 0d%s\n", dstr);          \
 273    } while (0)
 274
 275 #define ASM_OUTPUT_SKIP(FILE,SIZE)  \
 276   fprintf (FILE, "\t.space %u\n", (SIZE))
 277
 278 #if 0
 279 /* The NEWS assembler in version 3.4 complains about fmove.d, but this
 280    macro proved not to work right.  3.4 is old, so forget about it. */
 281 #define ASM_OUTPUT_OPCODE(FILE, STRING) \
 282 {                                               \
 283   if (!strncmp (STRING, "fmove.d", 7)           \
 284       && CONSTANT_P (operands[1]))              \
 285     {                                           \
 286       fprintf (FILE, "fmove.x");                \
 287       STRING += 7;                              \
 288     }                                           \
 289 }
 290 #endif
 291
 292 /* Store in OUTPUT a string (made with alloca) containing
 293    an assembler-name for a local static variable named NAME.
 294    LABELNO is an integer which is different for each call.  */
 295
 296 #define ASM_FORMAT_PRIVATE_NAME(OUTPUT, NAME, LABELNO)  \
 297 ( (OUTPUT) = (char *) alloca (strlen ((NAME)) + 13),    \
 298   sprintf ((OUTPUT), "%s$$$%d", (NAME), (LABELNO)))
 299
 300 /* Output a float value (represented as a C double) as an immediate operand.
 301    This macro is a 68k-specific macro.  */
 302
 303 #undef ASM_OUTPUT_FLOAT_OPERAND
 304 #define ASM_OUTPUT_FLOAT_OPERAND(CODE,FILE,VALUE)                       \
 305  do {                                                                   \
 306       if (CODE == 'f')                                                  \
 307         {                                                               \
 308           char dstr[30];                                                \
 309           REAL_VALUE_TO_DECIMAL (VALUE, "%.9e", dstr);                  \
 310           if (REAL_VALUE_ISINF (VALUE) || REAL_VALUE_ISNAN (VALUE))     \
 311             {                                                           \
 312               if (REAL_VALUE_NEGATIVE (VALUE))                          \
 313                 fprintf (FILE, "#0f-99e999");                           \
 314               else                                                      \
 315                 fprintf (FILE, "#0f99e999");                            \
 316             }                                                           \
 317           else if (REAL_VALUE_MINUS_ZERO (VALUE))                       \
 318             fprintf (FILE, "#0f-0.0");                                  \
 319           else                                                          \
 320             fprintf (FILE, "#0f%s", dstr);                              \
 321         }                                                               \
 322       else                                                              \
 323         {                                                               \
 324           long l;                                                       \
 325           REAL_VALUE_TO_TARGET_SINGLE (VALUE, l);                       \
 326           fprintf (FILE, "#0x%lx", l);                                  \
 327         }                                                               \
 328      } while (0)
 329
 330 /* Output a double value (represented as a C double) as an immediate operand.
 331    This macro is a 68k-specific macro.  */
 332 #undef ASM_OUTPUT_DOUBLE_OPERAND
 333 #define ASM_OUTPUT_DOUBLE_OPERAND(FILE,VALUE)                           \
 334  do { char dstr[30];                                                    \
 335       REAL_VALUE_TO_DECIMAL (VALUE, "%.20e", dstr );                    \
 336       if (REAL_VALUE_ISINF (VALUE) || REAL_VALUE_ISNAN (VALUE))         \
 337         {                                                               \
 338         if (REAL_VALUE_NEGATIVE (VALUE))                                \
 339           fprintf (FILE, "#0d-99e999");                                 \
 340         else                                                            \
 341           fprintf (FILE, "#0d99e999");                                  \
 342         }                                                               \
 343       else if (REAL_VALUE_MINUS_ZERO (VALUE))                           \
 344           fprintf (FILE, "#0d-0.0");                                    \
 345       else                                                              \
 346           fprintf (FILE, "#0d%s", dstr);                                \
 347     } while (0)
 348
 349 /* Note, long double immediate operands are not actually
 350    generated by m68k.md.  */
 351 #undef ASM_OUTPUT_LONG_DOUBLE_OPERAND
 352 #define ASM_OUTPUT_LONG_DOUBLE_OPERAND(FILE,VALUE)                      \
 353  do { char dstr[30];                                                    \
 354       REAL_VALUE_TO_DECIMAL (VALUE, "%.20g", dstr);                     \
 355       asm_fprintf (FILE, "%I0r%s", dstr);                               \
 356     } while (0)
 357
 358 #if 0
 359 #undef PRINT_OPERAND
 360 #define PRINT_OPERAND(FILE, X, CODE)  \
 361 { if (CODE == '.') fprintf (FILE, ".");                                 \
 362   else if (CODE == '#') fprintf (FILE, "#");                            \
 363   else if (CODE == '-') fprintf (FILE, "-(sp)");                        \
 364   else if (CODE == '+') fprintf (FILE, "(sp)+");                        \
 365   else if (CODE == '@') fprintf (FILE, "(sp)");                         \
 366   else if (CODE == '!') fprintf (FILE, "fpcr");                         \
 367   else if (CODE == '$') {if (TARGET_68040_ONLY) fprintf (FILE, "s");}   \
 368   else if (CODE == '&') {if (TARGET_68040_ONLY) fprintf (FILE, "d");}   \
 369   else if (CODE == '/')                                                 \
 370     ;                                                                   \
 371   else if (GET_CODE (X) == REG)                                         \
 372     fprintf (FILE, "%s", reg_names[REGNO (X)]);                         \
 373   else if (GET_CODE (X) == MEM)                                         \
 374     output_address (XEXP (X, 0));                                       \
 375   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == SFmode)      \
 376     { REAL_VALUE_TYPE r;                                                \
 377       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 378       if (CODE == 'f')                                                  \
 379         { char dstr[30];                                                \
 380           REAL_VALUE_TO_DECIMAL (r, "%.9e", dstr);                      \
 381           if (REAL_VALUE_ISINF (r) || REAL_VALUE_ISNAN (r)) {           \
 382             if (REAL_VALUE_NEGATIVE (r))                                \
 383               fprintf (FILE, "#0f-99e999");                             \
 384             else                                                        \
 385               fprintf (FILE, "#0f99e999"); }                            \
 386           else if (REAL_VALUE_MINUS_ZERO (r))                           \
 387             fprintf (FILE, "#0f-0.0");                                  \
 388           else                                                          \
 389             fprintf (FILE, "#0f%s", dstr);                              \
 390         }                                                               \
 391       else                                                              \
 392         { long l;                                                       \
 393           REAL_VALUE_TO_TARGET_SINGLE (r, l);                           \
 394           fprintf (FILE, "#0x%x", l);                                   \
 395         }}                                                              \
 396   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == XFmode)      \
 397     { REAL_VALUE_TYPE r;                                                \
 398       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 399       ASM_OUTPUT_LONG_DOUBLE_OPERAND (FILE, r); }                       \
 400   else if (GET_CODE (X) == CONST_DOUBLE && GET_MODE (X) == DFmode)      \
 401     { REAL_VALUE_TYPE r; char dstr[30];                                 \
 402       REAL_VALUE_FROM_CONST_DOUBLE (r, X);                              \
 403       REAL_VALUE_TO_DECIMAL (r, "%.20e", dstr );                        \
 404       if (REAL_VALUE_ISINF (r) || REAL_VALUE_ISNAN (r)) {               \
 405         if (REAL_VALUE_NEGATIVE (r))                                    \
 406           fprintf (FILE, "#0d-99e999");                                 \
 407         else                                                            \
 408           fprintf (FILE, "#0d99e999"); }                                \
 409       else if (REAL_VALUE_MINUS_ZERO (r))                               \
 410           fprintf (FILE, "#0d-0.0");                                    \
 411       else                                                              \
 412           fprintf (FILE, "#0d%s", dstr); }                              \
 413   else if (CODE == 'b') output_addr_const (FILE, X);                    \
 414   else { putc ('#', FILE); output_addr_const (FILE, X); }}
 415 #endif
 416
 417 #undef PRINT_OPERAND_ADDRESS
 418 #define PRINT_OPERAND_ADDRESS(FILE, ADDR)  \
 419 { register rtx reg1, reg2, breg, ireg;                                  \
 420   register rtx addr = ADDR;                                             \
 421   rtx offset;                                                           \
 422   switch (GET_CODE (addr))                                              \
 423     {                                                                   \
 424     case REG:                                                           \
 425       fprintf (FILE, "(%s)", reg_names[REGNO (addr)]);                  \
 426       break;                                                            \
 427     case PRE_DEC:                                                       \
 428       fprintf (FILE, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);       \
 429       break;                                                            \
 430     case POST_INC:                                                      \
 431       fprintf (FILE, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);       \
 432       break;                                                            \
 433     case PLUS:                                                          \
 434       reg1 = 0; reg2 = 0;                                               \
 435       ireg = 0; breg = 0;                                               \
 436       offset = 0;                                                       \
 437       if (CONSTANT_ADDRESS_P (XEXP (addr, 0)))                          \
 438         {                                                               \
 439           offset = XEXP (addr, 0);                                      \
 440           addr = XEXP (addr, 1);                                        \
 441         }                                                               \
 442       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1)))                     \
 443         {                                                               \
 444           offset = XEXP (addr, 1);                                      \
 445           addr = XEXP (addr, 0);                                        \
 446         }                                                               \
 447       if (GET_CODE (addr) != PLUS) ;                                    \
 448       else if (GET_CODE (XEXP (addr, 0)) == SIGN_EXTEND)                \
 449         {                                                               \
 450           reg1 = XEXP (addr, 0);                                        \
 451           addr = XEXP (addr, 1);                                        \
 452         }                                                               \
 453       else if (GET_CODE (XEXP (addr, 1)) == SIGN_EXTEND)                \
 454         {                                                               \
 455           reg1 = XEXP (addr, 1);                                        \
 456           addr = XEXP (addr, 0);                                        \
 457         }                                                               \
 458       else if (GET_CODE (XEXP (addr, 0)) == MULT)                       \
 459         {                                                               \
 460           reg1 = XEXP (addr, 0);                                        \
 461           addr = XEXP (addr, 1);                                        \
 462         }                                                               \
 463       else if (GET_CODE (XEXP (addr, 1)) == MULT)                       \
 464         {                                                               \
 465           reg1 = XEXP (addr, 1);                                        \
 466           addr = XEXP (addr, 0);                                        \
 467         }                                                               \
 468       else if (GET_CODE (XEXP (addr, 0)) == REG)                        \
 469         {                                                               \
 470           reg1 = XEXP (addr, 0);                                        \
 471           addr = XEXP (addr, 1);                                        \
 472         }                                                               \
 473       else if (GET_CODE (XEXP (addr, 1)) == REG)                        \
 474         {                                                               \
 475           reg1 = XEXP (addr, 1);                                        \
 476           addr = XEXP (addr, 0);                                        \
 477         }                                                               \
 478       if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT             \
 479           || GET_CODE (addr) == SIGN_EXTEND)                            \
 480         { if (reg1 == 0) reg1 = addr; else reg2 = addr; addr = 0; }     \
 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.b,pc,%s.w",                            \
 495                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 496                      reg_names[REGNO (XEXP (ireg, 0))]);                \
 497           else                                                          \
 498             fprintf (FILE, "(L%d.b,pc,%s.l",                            \
 499                      CODE_LABEL_NUMBER (XEXP (addr, 0)),                \
 500                      reg_names[REGNO (ireg)]);                          \
 501           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 502           putc (')', FILE);                                             \
 503           break; }                                                      \
 504       if (breg != 0 && ireg == 0 && GET_CODE (addr) == LABEL_REF)       \
 505         { fprintf (FILE, "(L%d.b,pc,%s.l",                              \
 506                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 507                    reg_names[REGNO (breg)]);                            \
 508           putc (')', FILE);                                             \
 509           break; }                                                      \
 510       if (ireg != 0 || breg != 0)                                       \
 511         { int scale = 1;                                                \
 512           if (breg == 0)                                                \
 513             abort ();                                                   \
 514           if (addr && GET_CODE (addr) == LABEL_REF) abort ();           \
 515           fprintf (FILE, "(");                                          \
 516           if (addr != 0) {                                              \
 517             output_addr_const (FILE, addr);                             \
 518             putc (',', FILE); }                                         \
 519           fprintf (FILE, "%s", reg_names[REGNO (breg)]);                \
 520           if (ireg != 0)                                                \
 521             putc (',', FILE);                                           \
 522           if (ireg != 0 && GET_CODE (ireg) == MULT)                     \
 523             { scale = INTVAL (XEXP (ireg, 1));                          \
 524               ireg = XEXP (ireg, 0); }                                  \
 525           if (ireg != 0 && GET_CODE (ireg) == SIGN_EXTEND)              \
 526             fprintf (FILE, "%s.w", reg_names[REGNO (XEXP (ireg, 0))]);  \
 527           else if (ireg != 0)                                           \
 528             fprintf (FILE, "%s.l", reg_names[REGNO (ireg)]);            \
 529           if (scale != 1) fprintf (FILE, "*%d", scale);                 \
 530           putc (')', FILE);                                             \
 531           break;                                                        \
 532         }                                                               \
 533       else if (reg1 != 0 && GET_CODE (addr) == LABEL_REF)               \
 534         { fprintf (FILE, "(L%d.b,pc,%s.l)",                             \
 535                    CODE_LABEL_NUMBER (XEXP (addr, 0)),                  \
 536                    reg_names[REGNO (reg1)]);                            \
 537           break; }                                                      \
 538     default:                                                            \
 539       if (GET_CODE (addr) == CONST_INT                                  \
 540           && INTVAL (addr) < 0x8000                                     \
 541           && INTVAL (addr) >= -0x8000)                                  \
 542         fprintf (FILE, "%d.w", INTVAL (addr));                          \
 543       else                                                              \
 544         output_addr_const (FILE, addr);                                 \
 545     }}
 546
 547 #else /* Using GAS, which uses the MIT assembler syntax, like a Sun.  */
 548
 549 #define FUNCTION_PROFILER(FILE, LABEL_NO) \
 550    fprintf (FILE, "\tmovl #LP%d,d0\n\tjsr mcount\n", (LABEL_NO));
 551
 552 #endif /* MOTOROLA */