gdb/m68k-pinsn.c

   1 /* Print m68k instructions for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 GDB 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 1, or (at your option)
   9 any later version.
  10
  11 GDB 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 GDB; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include <stdio.h>
  21
  22 #include <setjmp.h>
  23 #include <signal.h>
  24
  25 #include "defs.h"
  26 #include "param.h"
  27 #include "symtab.h"
  28 #include "opcode.h"
  29
  30 /* 68k instructions are never longer than this many bytes.  */
  31 #define MAXLEN 22
  32
  33 /* Number of elements in the opcode table.  */
  34 #define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
  35
  36 extern char *reg_names[];
  37 char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
  38                      "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
  39
  40 static unsigned char *print_insn_arg ();
  41 static unsigned char *print_indexed ();
  42 static void print_base ();
  43 static int fetch_arg ();
  44
  45 #define NEXTBYTE(p)  (p += 2, ((char *)p)[-1])
  46
  47 #define NEXTWORD(p)  \
  48   (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
  49
  50 #define NEXTLONG(p)  \
  51   (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
  52
  53 #define NEXTSINGLE(p) \
  54   (p += 4, *((float *)(p - 4)))
  55
  56 #define NEXTDOUBLE(p) \
  57   (p += 8, *((double *)(p - 8)))
  58
  59 #define NEXTEXTEND(p) \
  60   (p += 12, 0.0)        /* Need a function to convert from extended to double
  61                            precision... */
  62
  63 #define NEXTPACKED(p) \
  64   (p += 12, 0.0)        /* Need a function to convert from packed to double
  65                            precision.   Actually, it's easier to print a
  66                            packed number than a double anyway, so maybe
  67                            there should be a special case to handle this... */
  68 \f
  69 /* Print the m68k instruction at address MEMADDR in debugged memory,
  70    on STREAM.  Returns length of the instruction, in bytes.  */
  71
  72 int
  73 print_insn (memaddr, stream)
  74      CORE_ADDR memaddr;
  75      FILE *stream;
  76 {
  77   unsigned char buffer[MAXLEN];
  78   register int i;
  79   register unsigned char *p;
  80   register char *d;
  81   register int bestmask;
  82   int best;
  83
  84   read_memory (memaddr, buffer, MAXLEN);
  85
  86   bestmask = 0;
  87   best = -1;
  88   for (i = 0; i < NOPCODES; i++)
  89     {
  90       register unsigned int opcode = m68k_opcodes[i].opcode;
  91       register unsigned int match = m68k_opcodes[i].match;
  92       if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
  93           && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
  94           && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
  95           && ((0xff & buffer[3] & match) == (0xff & opcode)))
  96         {
  97           /* Don't use for printout the variants of divul and divsl
  98              that have the same register number in two places.
  99              The more general variants will match instead.  */
 100           for (d = m68k_opcodes[i].args; *d; d += 2)
 101             if (d[1] == 'D')
 102               break;
 103
 104           /* Don't use for printout the variants of most floating
 105              point coprocessor instructions which use the same
 106              register number in two places, as above. */
 107           if (*d == 0)
 108             for (d = m68k_opcodes[i].args; *d; d += 2)
 109               if (d[1] == 't')
 110                 break;
 111
 112           if (*d == 0 && match > bestmask)
 113             {
 114               best = i;
 115               bestmask = match;
 116             }
 117         }
 118     }
 119
 120   /* Handle undefined instructions.  */
 121   if (best < 0)
 122     {
 123       fprintf_filtered (stream, "0%o", (buffer[0] << 8) + buffer[1]);
 124       return 2;
 125     }
 126
 127   fprintf_filtered (stream, "%s", m68k_opcodes[best].name);
 128
 129   /* Point at first word of argument data,
 130      and at descriptor for first argument.  */
 131   p = buffer + 2;
 132
 133   /* Why do this this way? -MelloN */
 134   for (d = m68k_opcodes[best].args; *d; d += 2)
 135     {
 136       if (d[0] == '#')
 137         {
 138           if (d[1] == 'l' && p - buffer < 6)
 139             p = buffer + 6;
 140           else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
 141             p = buffer + 4;
 142         }
 143       if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
 144         p = buffer + 4;
 145       if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
 146         p = buffer + 6;
 147       if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
 148         p = buffer + 4;
 149     }
 150
 151   d = m68k_opcodes[best].args;
 152
 153   if (*d)
 154     fputs_filtered (" ", stream);
 155
 156   while (*d)
 157     {
 158       p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
 159       d += 2;
 160       if (*d && *(d - 2) != 'I' && *d != 'k')
 161         fputs_filtered (",", stream);
 162     }
 163   return p - buffer;
 164 }
 165
 166 static unsigned char *
 167 print_insn_arg (d, buffer, p, addr, stream)
 168      char *d;
 169      unsigned char *buffer;
 170      register unsigned char *p;
 171      CORE_ADDR addr;            /* PC for this arg to be relative to */
 172      FILE *stream;
 173 {
 174   register int val;
 175   register int place = d[1];
 176   int regno;
 177   register char *regname;
 178   register unsigned char *p1;
 179   register double flval;
 180   int flt_p;
 181
 182   switch (*d)
 183     {
 184     case 'C':
 185       fprintf_filtered (stream, "ccr");
 186       break;
 187
 188     case 'S':
 189       fprintf_filtered (stream, "sr");
 190       break;
 191
 192     case 'U':
 193       fprintf_filtered (stream, "usp");
 194       break;
 195
 196     case 'J':
 197       {
 198         static struct { char *name; int value; } names[]
 199           = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
 200              {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
 201              {"msp", 0x803}, {"isp", 0x804}};
 202
 203         val = fetch_arg (buffer, place, 12);
 204         for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
 205           if (names[regno].value == val)
 206             {
 207               fprintf_filtered (stream, names[regno].name);
 208               break;
 209             }
 210         if (regno < 0)
 211           fprintf_filtered (stream, "%d", val);
 212       }
 213       break;
 214
 215     case 'Q':
 216       val = fetch_arg (buffer, place, 3);
 217       if (val == 0) val = 8;
 218       fprintf_filtered (stream, "#%d", val);
 219       break;
 220
 221     case 'M':
 222       val = fetch_arg (buffer, place, 8);
 223       if (val & 0x80)
 224         val = val - 0x100;
 225       fprintf_filtered (stream, "#%d", val);
 226       break;
 227
 228     case 'T':
 229       val = fetch_arg (buffer, place, 4);
 230       fprintf_filtered (stream, "#%d", val);
 231       break;
 232
 233     case 'D':
 234       fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
 235       break;
 236
 237     case 'A':
 238       fprintf_filtered (stream, "%s",
 239                         reg_names[fetch_arg (buffer, place, 3) + 010]);
 240       break;
 241
 242     case 'R':
 243       fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
 244       break;
 245
 246     case 'F':
 247       fprintf_filtered (stream, "fp%d", fetch_arg (buffer, place, 3));
 248       break;
 249
 250     case 'O':
 251       val = fetch_arg (buffer, place, 6);
 252       if (val & 0x20)
 253         fprintf_filtered (stream, "%s", reg_names [val & 7]);
 254       else
 255         fprintf_filtered (stream, "%d", val);
 256       break;
 257
 258     case '+':
 259       fprintf_filtered (stream, "%s@+",
 260                         reg_names[fetch_arg (buffer, place, 3) + 8]);
 261       break;
 262
 263     case '-':
 264       fprintf_filtered (stream, "%s@-",
 265                reg_names[fetch_arg (buffer, place, 3) + 8]);
 266       break;
 267
 268     case 'k':
 269       if (place == 'k')
 270         fprintf_filtered (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
 271       else if (place == 'C')
 272         {
 273           val = fetch_arg (buffer, place, 7);
 274           if ( val > 63 )               /* This is a signed constant. */
 275             val -= 128;
 276           fprintf_filtered (stream, "{#%d}", val);
 277         }
 278       else
 279         error ("Invalid arg format in opcode table: \"%c%c\".",
 280                *d, place);
 281       break;
 282
 283     case '#':
 284     case '^':
 285       p1 = buffer + (*d == '#' ? 2 : 4);
 286       if (place == 's')
 287         val = fetch_arg (buffer, place, 4);
 288       else if (place == 'C')
 289         val = fetch_arg (buffer, place, 7);
 290       else if (place == '8')
 291         val = fetch_arg (buffer, place, 3);
 292       else if (place == '3')
 293         val = fetch_arg (buffer, place, 8);
 294       else if (place == 'b')
 295         val = NEXTBYTE (p1);
 296       else if (place == 'w')
 297         val = NEXTWORD (p1);
 298       else if (place == 'l')
 299         val = NEXTLONG (p1);
 300       else
 301         error ("Invalid arg format in opcode table: \"%c%c\".",
 302                *d, place);
 303       fprintf_filtered (stream, "#%d", val);
 304       break;
 305
 306     case 'B':
 307       if (place == 'b')
 308         val = NEXTBYTE (p);
 309       else if (place == 'w')
 310         val = NEXTWORD (p);
 311       else if (place == 'l')
 312         val = NEXTLONG (p);
 313       else if (place == 'g')
 314         {
 315           val = ((char *)buffer)[1];
 316           if (val == 0)
 317             val = NEXTWORD (p);
 318           else if (val == -1)
 319             val = NEXTLONG (p);
 320         }
 321       else if (place == 'c')
 322         {
 323           if (buffer[1] & 0x40)         /* If bit six is one, long offset */
 324             val = NEXTLONG (p);
 325           else
 326             val = NEXTWORD (p);
 327         }
 328       else
 329         error ("Invalid arg format in opcode table: \"%c%c\".",
 330                *d, place);
 331
 332       print_address (addr + val, stream);
 333       break;
 334
 335     case 'd':
 336       val = NEXTWORD (p);
 337       fprintf_filtered (stream, "%s@(%d)",
 338                         reg_names[fetch_arg (buffer, place, 3)], val);
 339       break;
 340
 341     case 's':
 342       fprintf_filtered (stream, "%s",
 343                         fpcr_names[fetch_arg (buffer, place, 3)]);
 344       break;
 345
 346     case 'I':
 347       val = fetch_arg (buffer, 'd', 3);           /* Get coprocessor ID... */
 348       if (val != 1)                             /* Unusual coprocessor ID? */
 349         fprintf_filtered (stream, "(cpid=%d) ", val);
 350       if (place == 'i')
 351         p += 2;                      /* Skip coprocessor extended operands */
 352       break;
 353
 354     case '*':
 355     case '~':
 356     case '%':
 357     case ';':
 358     case '@':
 359     case '!':
 360     case '$':
 361     case '?':
 362     case '/':
 363     case '&':
 364
 365       if (place == 'd')
 366         {
 367           val = fetch_arg (buffer, 'x', 6);
 368           val = ((val & 7) << 3) + ((val >> 3) & 7);
 369         }
 370       else
 371         val = fetch_arg (buffer, 's', 6);
 372
 373       /* Get register number assuming address register.  */
 374       regno = (val & 7) + 8;
 375       regname = reg_names[regno];
 376       switch (val >> 3)
 377         {
 378         case 0:
 379           fprintf_filtered (stream, "%s", reg_names[val]);
 380           break;
 381
 382         case 1:
 383           fprintf_filtered (stream, "%s", regname);
 384           break;
 385
 386         case 2:
 387           fprintf_filtered (stream, "%s@", regname);
 388           break;
 389
 390         case 3:
 391           fprintf_filtered (stream, "%s@+", regname);
 392           break;
 393
 394         case 4:
 395           fprintf_filtered (stream, "%s@-", regname);
 396           break;
 397
 398         case 5:
 399           val = NEXTWORD (p);
 400           fprintf_filtered (stream, "%s@(%d)", regname, val);
 401           break;
 402
 403         case 6:
 404           p = print_indexed (regno, p, addr, stream);
 405           break;
 406
 407         case 7:
 408           switch (val & 7)
 409             {
 410             case 0:
 411               val = NEXTWORD (p);
 412               fprintf_filtered (stream, "@#");
 413               print_address (val, stream);
 414               break;
 415
 416             case 1:
 417               val = NEXTLONG (p);
 418               fprintf_filtered (stream, "@#");
 419               print_address (val, stream);
 420               break;
 421
 422             case 2:
 423               val = NEXTWORD (p);
 424               print_address (addr + val, stream);
 425               break;
 426
 427             case 3:
 428               p = print_indexed (-1, p, addr, stream);
 429               break;
 430
 431             case 4:
 432               flt_p = 1;        /* Assume it's a float... */
 433               switch( place )
 434               {
 435                 case 'b':
 436                   val = NEXTBYTE (p);
 437                   flt_p = 0;
 438                   break;
 439
 440                 case 'w':
 441                   val = NEXTWORD (p);
 442                   flt_p = 0;
 443                   break;
 444
 445                 case 'l':
 446                   val = NEXTLONG (p);
 447                   flt_p = 0;
 448                   break;
 449
 450                 case 'f':
 451                   flval = NEXTSINGLE(p);
 452                   break;
 453
 454                 case 'F':
 455                   flval = NEXTDOUBLE(p);
 456                   break;
 457
 458                 case 'x':
 459                   flval = NEXTEXTEND(p);
 460                   break;
 461
 462                 case 'p':
 463                   flval = NEXTPACKED(p);
 464                   break;
 465
 466                 default:
 467                   error ("Invalid arg format in opcode table: \"%c%c\".",
 468                        *d, place);
 469               }
 470               if ( flt_p )      /* Print a float? */
 471                 fprintf_filtered (stream, "#%g", flval);
 472               else
 473                 fprintf_filtered (stream, "#%d", val);
 474               break;
 475
 476             default:
 477               fprintf_filtered (stream, "<invalid address mode 0%o>", val);
 478             }
 479         }
 480       break;
 481
 482     case 'L':
 483     case 'l':
 484         if (place == 'w')
 485           {
 486             char doneany;
 487             p1 = buffer + 2;
 488             val = NEXTWORD (p1);
 489             /* Move the pointer ahead if this point is farther ahead
 490                than the last.  */
 491             p = p1 > p ? p1 : p;
 492             if (val == 0)
 493               {
 494                 fputs_filtered ("#0", stream);
 495                 break;
 496               }
 497             if (*d == 'l')
 498               {
 499                 register int newval = 0;
 500                 for (regno = 0; regno < 16; ++regno)
 501                   if (val & (0x8000 >> regno))
 502                     newval |= 1 << regno;
 503                 val = newval;
 504               }
 505             val &= 0xffff;
 506             doneany = 0;
 507             for (regno = 0; regno < 16; ++regno)
 508               if (val & (1 << regno))
 509                 {
 510                   int first_regno;
 511                   if (doneany)
 512                     fputs_filtered ("/", stream);
 513                   doneany = 1;
 514                   fprintf_filtered (stream, "%s", reg_names[regno]);
 515                   first_regno = regno;
 516                   while (val & (1 << (regno + 1)))
 517                     ++regno;
 518                   if (regno > first_regno)
 519                     fprintf_filtered (stream, "-%s", reg_names[regno]);
 520                 }
 521           }
 522         else if (place == '3')
 523           {
 524             /* `fmovem' insn.  */
 525             char doneany;
 526             val = fetch_arg (buffer, place, 8);
 527             if (val == 0)
 528               {
 529                 fputs_filtered ("#0", stream);
 530                 break;
 531               }
 532             if (*d == 'l')
 533               {
 534                 register int newval = 0;
 535                 for (regno = 0; regno < 8; ++regno)
 536                   if (val & (0x80 >> regno))
 537                     newval |= 1 << regno;
 538                 val = newval;
 539               }
 540             val &= 0xff;
 541             doneany = 0;
 542             for (regno = 0; regno < 8; ++regno)
 543               if (val & (1 << regno))
 544                 {
 545                   int first_regno;
 546                   if (doneany)
 547                     fputs_filtered ("/", stream);
 548                   doneany = 1;
 549                   fprintf_filtered (stream, "fp%d", regno);
 550                   first_regno = regno;
 551                   while (val & (1 << (regno + 1)))
 552                     ++regno;
 553                   if (regno > first_regno)
 554                     fprintf_filtered (stream, "-fp%d", regno);
 555                 }
 556           }
 557         else
 558           abort ();
 559       break;
 560
 561     default:
 562       error ("Invalid arg format in opcode table: \"%c\".", *d);
 563     }
 564
 565   return (unsigned char *) p;
 566 }
 567
 568 /* Fetch BITS bits from a position in the instruction specified by CODE.
 569    CODE is a "place to put an argument", or 'x' for a destination
 570    that is a general address (mode and register).
 571    BUFFER contains the instruction.  */
 572
 573 static int
 574 fetch_arg (buffer, code, bits)
 575      unsigned char *buffer;
 576      char code;
 577      int bits;
 578 {
 579   register int val;
 580   switch (code)
 581     {
 582     case 's':
 583       val = buffer[1];
 584       break;
 585
 586     case 'd':                   /* Destination, for register or quick.  */
 587       val = (buffer[0] << 8) + buffer[1];
 588       val >>= 9;
 589       break;
 590
 591     case 'x':                   /* Destination, for general arg */
 592       val = (buffer[0] << 8) + buffer[1];
 593       val >>= 6;
 594       break;
 595
 596     case 'k':
 597       val = (buffer[3] >> 4);
 598       break;
 599
 600     case 'C':
 601       val = buffer[3];
 602       break;
 603
 604     case '1':
 605       val = (buffer[2] << 8) + buffer[3];
 606       val >>= 12;
 607       break;
 608
 609     case '2':
 610       val = (buffer[2] << 8) + buffer[3];
 611       val >>= 6;
 612       break;
 613
 614     case '3':
 615     case 'j':
 616       val = (buffer[2] << 8) + buffer[3];
 617       break;
 618
 619     case '4':
 620       val = (buffer[4] << 8) + buffer[5];
 621       val >>= 12;
 622       break;
 623
 624     case '5':
 625       val = (buffer[4] << 8) + buffer[5];
 626       val >>= 6;
 627       break;
 628
 629     case '6':
 630       val = (buffer[4] << 8) + buffer[5];
 631       break;
 632
 633     case '7':
 634       val = (buffer[2] << 8) + buffer[3];
 635       val >>= 7;
 636       break;
 637
 638     case '8':
 639       val = (buffer[2] << 8) + buffer[3];
 640       val >>= 10;
 641       break;
 642
 643     default:
 644       abort ();
 645     }
 646
 647   switch (bits)
 648     {
 649     case 3:
 650       return val & 7;
 651     case 4:
 652       return val & 017;
 653     case 5:
 654       return val & 037;
 655     case 6:
 656       return val & 077;
 657     case 7:
 658       return val & 0177;
 659     case 8:
 660       return val & 0377;
 661     case 12:
 662       return val & 07777;
 663     default:
 664       abort ();
 665     }
 666 }
 667
 668 /* Print an indexed argument.  The base register is BASEREG (-1 for pc).
 669    P points to extension word, in buffer.
 670    ADDR is the nominal core address of that extension word.  */
 671
 672 static unsigned char *
 673 print_indexed (basereg, p, addr, stream)
 674      int basereg;
 675      unsigned char *p;
 676      FILE *stream;
 677      CORE_ADDR addr;
 678 {
 679   register int word;
 680   static char *scales[] = {"", "*2", "*4", "*8"};
 681   register int base_disp;
 682   register int outer_disp;
 683   char buf[40];
 684
 685   word = NEXTWORD (p);
 686
 687   /* Generate the text for the index register.
 688      Where this will be output is not yet determined.  */
 689   sprintf (buf, "[%s.%c%s]",
 690            reg_names[(word >> 12) & 0xf],
 691            (word & 0x800) ? 'l' : 'w',
 692            scales[(word >> 9) & 3]);
 693
 694   /* Handle the 68000 style of indexing.  */
 695
 696   if ((word & 0x100) == 0)
 697     {
 698       print_base (basereg,
 699                   ((word & 0x80) ? word | 0xff00 : word & 0xff)
 700                   + ((basereg == -1) ? addr : 0),
 701                   stream);
 702       fputs_filtered (buf, stream);
 703       return p;
 704     }
 705
 706   /* Handle the generalized kind.  */
 707   /* First, compute the displacement to add to the base register.  */
 708
 709   if (word & 0200)
 710     basereg = -2;
 711   if (word & 0100)
 712     buf[0] = 0;
 713   base_disp = 0;
 714   switch ((word >> 4) & 3)
 715     {
 716     case 2:
 717       base_disp = NEXTWORD (p);
 718       break;
 719     case 3:
 720       base_disp = NEXTLONG (p);
 721     }
 722   if (basereg == -1)
 723     base_disp += addr;
 724
 725   /* Handle single-level case (not indirect) */
 726
 727   if ((word & 7) == 0)
 728     {
 729       print_base (basereg, base_disp, stream);
 730       fputs_filtered (buf, stream);
 731       return p;
 732     }
 733
 734   /* Two level.  Compute displacement to add after indirection.  */
 735
 736   outer_disp = 0;
 737   switch (word & 3)
 738     {
 739     case 2:
 740       outer_disp = NEXTWORD (p);
 741       break;
 742     case 3:
 743       outer_disp = NEXTLONG (p);
 744     }
 745
 746   fprintf_filtered (stream, "%d(", outer_disp);
 747   print_base (basereg, base_disp, stream);
 748
 749   /* If postindexed, print the closeparen before the index.  */
 750   if (word & 4)
 751     fprintf_filtered (stream, ")%s", buf);
 752   /* If preindexed, print the closeparen after the index.  */
 753   else
 754     fprintf_filtered (stream, "%s)", buf);
 755
 756   return p;
 757 }
 758
 759 /* Print a base register REGNO and displacement DISP, on STREAM.
 760    REGNO = -1 for pc, -2 for none (suppressed).  */
 761
 762 static void
 763 print_base (regno, disp, stream)
 764      int regno;
 765      int disp;
 766      FILE *stream;
 767 {
 768   if (regno == -2)
 769     fprintf_filtered (stream, "%d", disp);
 770   else if (regno == -1)
 771     fprintf_filtered (stream, "0x%x", disp);
 772   else
 773     fprintf_filtered (stream, "%d(%s)", disp, reg_names[regno]);
 774 }
 775 \f
 776 /* Nonzero if the host system has a 68881 (or compatible)
 777    floating-point unit.  This does *not* indicate whether the target
 778    system has a co-processor, just whether the host system does.
 779    There might be a difference in the case of remote debugging.  */
 780 static int have_fpu = 1;
 781
 782 /* This is not part of insn printing, but it is machine-specific,
 783    so this is a convenient place to put it.
 784
 785    Convert a 68881 extended float to a double.
 786    FROM is the address of the extended float.
 787    Store the double in *TO.  */
 788
 789 convert_from_68881 (from, to)
 790      char *from;
 791      double *to;
 792 {
 793   if (!have_fpu)
 794     {
 795       *to = 0.0;
 796       return;
 797     }
 798 #ifdef HPUX_ASM
 799   asm ("mov.l 8(%a6),%a0");
 800   asm ("mov.l 12(%a6),%a1");
 801   asm ("fmove.x (%a0),%fp0");
 802   asm ("fmove.d %fp0,(%a1)");
 803 #else /* not HPUX_ASM */
 804 #if 0
 805   asm ("movl a6@(8),a0");
 806   asm ("movl a6@(12),a1");
 807   asm ("fmovex a0@,fp0");
 808   asm ("fmoved fp0,a1@");
 809 #else
 810   /* Hand-assemble those insns since some assemblers lose
 811      and some have different syntax.  */
 812   asm (".word 020156");
 813   asm (".word 8");
 814   asm (".word 021156");
 815   asm (".word 12");
 816   asm (".long 0xf2104800");
 817   asm (".long 0xf2117400");
 818 #endif
 819 #endif /* not HPUX_ASM */
 820 }
 821
 822 /* The converse: convert the double *FROM to an extended float
 823    and store where TO points.  */
 824
 825 convert_to_68881 (from, to)
 826      double *from;
 827      char *to;
 828 {
 829   if (!have_fpu)
 830       return;
 831 #ifdef HPUX_ASM
 832   asm ("mov.l 8(%a6),%a0");
 833   asm ("mov.l 12(%a6),%a1");
 834   asm ("fmove.d (%a0),%fp0");
 835   asm ("fmove.x %fp0,(%a1)");
 836 #else /* not HPUX_ASM */
 837 #if 0
 838   asm ("movl a6@(8),a0");
 839   asm ("movl a6@(12),a1");
 840   asm ("fmoved a0@,fp0");
 841   asm ("fmovex fp0,a1@");
 842 #else
 843   /* Hand-assemble those insns since some assemblers lose.  */
 844   asm (".word 020156");
 845   asm (".word 8");
 846   asm (".word 021156");
 847   asm (".word 12");
 848   asm (".long 0xf2105400");
 849   asm (".long 0xf2116800");
 850 #endif
 851 #endif /* not HPUX_ASM */
 852 }
 853
 854 static jmp_buf  fpu_check;
 855
 856 void
 857 sigemt()
 858 {
 859     have_fpu = 0;
 860     longjmp (fpu_check, 1);
 861 }
 862
 863 void
 864 _initialize_pinsn()
 865 {
 866   /* Want to figure out if we've got a coprocessor. The idea is to catch the
 867      signal that gets delivered if no coprocessor is around (SIGEMT) then
 868      execute a coprocessor instruction and see what happens. have_fpu is set
 869      to zero if the EMT signal arrives. Else it is left at 1.  */
 870   /* If this turns out not to be portable to all 68k machines, we'll
 871      have to move it to the dep files.  */
 872   void (*emthandler) ();
 873
 874   emthandler = (void (*) ()) signal (SIGEMT, sigemt);
 875   if (!setjmp (fpu_check))
 876     {
 877 #if defined(HPUX_ASM)
 878       asm (" long       0xf2000600");   /* fmovel fp0, d0 */
 879 #else
 880       asm(".long        0xf2000600");   /* fmovel fp0, d0 */
 881 #endif
 882     }
 883   signal(SIGEMT, emthandler);
 884 }