![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68k-pinsn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb|
Return to m68k-pinsn.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / emacs-18.55 / gdb |
1.1 ! root 1: /* Print m68k instructions for GDB, the GNU debugger. ! 2: Copyright (C) 1986, 1987 Free Software Foundation, Inc. ! 3: ! 4: GDB is distributed in the hope that it will be useful, but WITHOUT ANY ! 5: WARRANTY. No author or distributor accepts responsibility to anyone ! 6: for the consequences of using it or for whether it serves any ! 7: particular purpose or works at all, unless he says so in writing. ! 8: Refer to the GDB General Public License for full details. ! 9: ! 10: Everyone is granted permission to copy, modify and redistribute GDB, ! 11: but only under the conditions described in the GDB General Public ! 12: License. A copy of this license is supposed to have been given to you ! 13: along with GDB so you can know your rights and responsibilities. It ! 14: should be in a file named COPYING. Among other things, the copyright ! 15: notice and this notice must be preserved on all copies. ! 16: ! 17: In other words, go ahead and share GDB, but don't try to stop ! 18: anyone else from sharing it farther. Help stamp out software hoarding! ! 19: */ ! 20: ! 21: #include <stdio.h> ! 22: ! 23: #include "defs.h" ! 24: #include "param.h" ! 25: #include "symtab.h" ! 26: #include "opcode.h" ! 27: ! 28: /* 68k instructions are never longer than this many bytes. */ ! 29: #define MAXLEN 22 ! 30: ! 31: /* Number of elements in the opcode table. */ ! 32: #define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0]) ! 33: ! 34: extern char *reg_names[]; ! 35: char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr", ! 36: "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"}; ! 37: ! 38: static unsigned char *print_insn_arg (); ! 39: static unsigned char *print_indexed (); ! 40: static void print_base (); ! 41: static int fetch_arg (); ! 42: ! 43: #define NEXTBYTE(p) (p += 2, ((char *)p)[-1]) ! 44: ! 45: #define NEXTWORD(p) \ ! 46: (p += 2, ((((char *)p)[-2]) << 8) + p[-1]) ! 47: ! 48: #define NEXTLONG(p) \ ! 49: (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1]) ! 50: ! 51: #define NEXTSINGLE(p) \ ! 52: (p += 4, *((float *)(p - 4))) ! 53: ! 54: #define NEXTDOUBLE(p) \ ! 55: (p += 8, *((double *)(p - 8))) ! 56: ! 57: #define NEXTEXTEND(p) \ ! 58: (p += 12, 0.0) /* Need a function to convert from extended to double ! 59: precision... */ ! 60: ! 61: #define NEXTPACKED(p) \ ! 62: (p += 12, 0.0) /* Need a function to convert from packed to double ! 63: precision. Actually, it's easier to print a ! 64: packed number than a double anyway, so maybe ! 65: there should be a special case to handle this... */ ! 66: ! 67: /* Print the m68k instruction at address MEMADDR in debugged memory, ! 68: on STREAM. Returns length of the instruction, in bytes. */ ! 69: ! 70: int ! 71: print_insn (memaddr, stream) ! 72: CORE_ADDR memaddr; ! 73: FILE *stream; ! 74: { ! 75: unsigned char buffer[MAXLEN]; ! 76: register int i; ! 77: register unsigned char *p; ! 78: register char *d; ! 79: register int bestmask; ! 80: int best; ! 81: ! 82: read_memory (memaddr, buffer, MAXLEN); ! 83: ! 84: bestmask = 0; ! 85: best = -1; ! 86: for (i = 0; i < NOPCODES; i++) ! 87: { ! 88: register unsigned int opcode = m68k_opcodes[i].opcode; ! 89: register unsigned int match = m68k_opcodes[i].match; ! 90: if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24))) ! 91: && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16))) ! 92: && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8))) ! 93: && ((0xff & buffer[3] & match) == (0xff & opcode))) ! 94: { ! 95: /* Don't use for printout the variants of divul and divsl ! 96: that have the same register number in two places. ! 97: The more general variants will match instead. */ ! 98: for (d = m68k_opcodes[i].args; *d; d += 2) ! 99: if (d[1] == 'D') ! 100: break; ! 101: ! 102: /* Don't use for printout the variants of most floating ! 103: point coprocessor instructions which use the same ! 104: register number in two places, as above. */ ! 105: if (*d == 0) ! 106: for (d = m68k_opcodes[i].args; *d; d += 2) ! 107: if (d[1] == 't') ! 108: break; ! 109: ! 110: if (*d == 0 && match > bestmask) ! 111: { ! 112: best = i; ! 113: bestmask = match; ! 114: } ! 115: } ! 116: } ! 117: ! 118: /* Handle undefined instructions. */ ! 119: if (best < 0) ! 120: { ! 121: fprintf (stream, "0%o", (buffer[0] << 8) + buffer[1]); ! 122: return 2; ! 123: } ! 124: ! 125: fprintf (stream, "%s", m68k_opcodes[best].name); ! 126: ! 127: /* Point at first word of argument data, ! 128: and at descriptor for first argument. */ ! 129: p = buffer + 2; ! 130: ! 131: /* Why do this this way? -MelloN */ ! 132: for (d = m68k_opcodes[best].args; *d; d += 2) ! 133: { ! 134: if (d[0] == '#') ! 135: { ! 136: if (d[1] == 'l' && p - buffer < 6) ! 137: p = buffer + 6; ! 138: else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' ) ! 139: p = buffer + 4; ! 140: } ! 141: if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4) ! 142: p = buffer + 4; ! 143: if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6) ! 144: p = buffer + 6; ! 145: } ! 146: ! 147: d = m68k_opcodes[best].args; ! 148: ! 149: if (*d) ! 150: fputc (' ', stream); ! 151: ! 152: while (*d) ! 153: { ! 154: p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream); ! 155: d += 2; ! 156: if (*d && *(d - 2) != 'I' && *d != 'k') ! 157: fprintf (stream, ","); ! 158: } ! 159: return p - buffer; ! 160: } ! 161: ! 162: static unsigned char * ! 163: print_insn_arg (d, buffer, p, addr, stream) ! 164: char *d; ! 165: unsigned char *buffer; ! 166: register unsigned char *p; ! 167: CORE_ADDR addr; /* PC for this arg to be relative to */ ! 168: FILE *stream; ! 169: { ! 170: register int val; ! 171: register int place = d[1]; ! 172: int regno; ! 173: register char *regname; ! 174: register unsigned char *p1; ! 175: register double flval; ! 176: int flt_p; ! 177: ! 178: switch (*d) ! 179: { ! 180: case 'C': ! 181: fprintf (stream, "ccr"); ! 182: break; ! 183: ! 184: case 'S': ! 185: fprintf (stream, "sr"); ! 186: break; ! 187: ! 188: case 'U': ! 189: fprintf (stream, "usp"); ! 190: break; ! 191: ! 192: case 'J': ! 193: { ! 194: static struct { char *name; int value; } names[] ! 195: = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002}, ! 196: {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802}, ! 197: {"msp", 0x803}, {"isp", 0x804}}; ! 198: ! 199: val = fetch_arg (buffer, place, 12); ! 200: for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--) ! 201: if (names[regno].value == val) ! 202: { ! 203: fprintf (stream, names[regno].name); ! 204: break; ! 205: } ! 206: if (regno < 0) ! 207: fprintf (stream, "%d", val); ! 208: } ! 209: break; ! 210: ! 211: case 'Q': ! 212: val = fetch_arg (buffer, place, 3); ! 213: if (val == 0) val = 8; ! 214: fprintf (stream, "#%d", val); ! 215: break; ! 216: ! 217: case 'M': ! 218: val = fetch_arg (buffer, place, 8); ! 219: if (val & 0x80) ! 220: val = val - 0x100; ! 221: fprintf (stream, "#%d", val); ! 222: break; ! 223: ! 224: case 'T': ! 225: val = fetch_arg (buffer, place, 4); ! 226: fprintf (stream, "#%d", val); ! 227: break; ! 228: ! 229: case 'D': ! 230: fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]); ! 231: break; ! 232: ! 233: case 'A': ! 234: fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3) + 010]); ! 235: break; ! 236: ! 237: case 'R': ! 238: fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]); ! 239: break; ! 240: ! 241: case 'F': ! 242: fprintf (stream, "fp%d", fetch_arg (buffer, place, 3)); ! 243: break; ! 244: ! 245: case 'O': ! 246: val = fetch_arg (buffer, place, 6); ! 247: if (val & 0x20) ! 248: fprintf (stream, "%s", reg_names [val & 7]); ! 249: else ! 250: fprintf (stream, "%d", val); ! 251: break; ! 252: ! 253: case '+': ! 254: fprintf (stream, "(%s)+", reg_names[fetch_arg (buffer, place, 3) + 8]); ! 255: break; ! 256: ! 257: case '-': ! 258: fprintf (stream, "-(%s)", reg_names[fetch_arg (buffer, place, 3) + 8]); ! 259: break; ! 260: ! 261: case 'k': ! 262: if (place == 'k') ! 263: fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]); ! 264: else if (place == 'C') ! 265: { ! 266: val = fetch_arg (buffer, place, 7); ! 267: if ( val > 63 ) /* This is a signed constant. */ ! 268: val -= 128; ! 269: fprintf (stream, "{#%d}", val); ! 270: } ! 271: else ! 272: error ("Invalid arg format in opcode table: \"%c%c\".", ! 273: *d, place); ! 274: break; ! 275: ! 276: case '#': ! 277: p1 = buffer + 2; ! 278: if (place == 's') ! 279: val = fetch_arg (buffer, place, 4); ! 280: else if (place == 'C') ! 281: val = fetch_arg (buffer, place, 7); ! 282: else if (place == '8') ! 283: val = fetch_arg (buffer, place, 3); ! 284: else if (place == '3') ! 285: val = fetch_arg (buffer, place, 8); ! 286: else if (place == 'b') ! 287: val = NEXTBYTE (p1); ! 288: else if (place == 'w') ! 289: val = NEXTWORD (p1); ! 290: else if (place == 'l') ! 291: val = NEXTLONG (p1); ! 292: else ! 293: error ("Invalid arg format in opcode table: \"%c%c\".", ! 294: *d, place); ! 295: fprintf (stream, "#%d", val); ! 296: break; ! 297: ! 298: case '^': ! 299: if (place == 's') ! 300: val = fetch_arg (buffer, place, 4); ! 301: else if (place == 'C') ! 302: val = fetch_arg (buffer, place, 7); ! 303: else if (place == '8') ! 304: val = fetch_arg (buffer, place, 3); ! 305: else if (place == 'b') ! 306: val = NEXTBYTE (p); ! 307: else if (place == 'w') ! 308: val = NEXTWORD (p); ! 309: else if (place == 'l') ! 310: val = NEXTLONG (p); ! 311: else ! 312: error ("Invalid arg format in opcode table: \"%c%c\".", ! 313: *d, place); ! 314: fprintf (stream, "#%d", val); ! 315: break; ! 316: ! 317: case 'B': ! 318: if (place == 'b') ! 319: val = NEXTBYTE (p); ! 320: else if (place == 'w') ! 321: val = NEXTWORD (p); ! 322: else if (place == 'l') ! 323: val = NEXTLONG (p); ! 324: else if (place == 'g') ! 325: { ! 326: val = ((char *)buffer)[1]; ! 327: if (val == 0) ! 328: val = NEXTWORD (p); ! 329: else if (val == -1) ! 330: val = NEXTLONG (p); ! 331: } ! 332: else if (place == 'c') ! 333: { ! 334: if (buffer[1] & 0x40) /* If bit six is one, long offset */ ! 335: val = NEXTLONG (p); ! 336: else ! 337: val = NEXTWORD (p); ! 338: } ! 339: else ! 340: error ("Invalid arg format in opcode table: \"%c%c\".", ! 341: *d, place); ! 342: ! 343: print_address (addr + val, stream); ! 344: break; ! 345: ! 346: case 'd': ! 347: val = NEXTWORD (p); ! 348: fprintf (stream, "%d(%s)", val, reg_names[fetch_arg (buffer, place, 3)]); ! 349: break; ! 350: ! 351: case 's': ! 352: fprintf (stream, "%s", fpcr_names[fetch_arg (buffer, place, 3)]); ! 353: break; ! 354: ! 355: case 'I': ! 356: val = fetch_arg (buffer, 'd', 3); /* Get coprocessor ID... */ ! 357: if (val != 1) /* Unusual coprocessor ID? */ ! 358: fprintf (stream, "(cpid=%d) ", val); ! 359: if (place == 'i') ! 360: p += 2; /* Skip coprocessor extended operands */ ! 361: break; ! 362: ! 363: case '*': ! 364: case '~': ! 365: case '%': ! 366: case ';': ! 367: case '@': ! 368: case '!': ! 369: case '$': ! 370: case '?': ! 371: case '/': ! 372: case '&': ! 373: ! 374: if (place == 'd') ! 375: { ! 376: val = fetch_arg (buffer, 'x', 6); ! 377: val = ((val & 7) << 3) + ((val >> 3) & 7); ! 378: } ! 379: else ! 380: val = fetch_arg (buffer, 's', 6); ! 381: ! 382: /* Get register number assuming address register. */ ! 383: regno = (val & 7) + 8; ! 384: regname = reg_names[regno]; ! 385: switch (val >> 3) ! 386: { ! 387: case 0: ! 388: fprintf (stream, "%s", reg_names[val]); ! 389: break; ! 390: ! 391: case 1: ! 392: fprintf (stream, "%s", regname); ! 393: break; ! 394: ! 395: case 2: ! 396: fprintf (stream, "(%s)", regname); ! 397: break; ! 398: ! 399: case 3: ! 400: fprintf (stream, "(%s)+", regname); ! 401: break; ! 402: ! 403: case 4: ! 404: fprintf (stream, "-(%s)", regname); ! 405: break; ! 406: ! 407: case 5: ! 408: val = NEXTWORD (p); ! 409: fprintf (stream, "%d(%s)", val, regname); ! 410: break; ! 411: ! 412: case 6: ! 413: p = print_indexed (regno, p, addr, stream); ! 414: break; ! 415: ! 416: case 7: ! 417: switch (val & 7) ! 418: { ! 419: case 0: ! 420: val = NEXTWORD (p); ! 421: fprintf (stream, "@#"); ! 422: print_address (val, stream); ! 423: break; ! 424: ! 425: case 1: ! 426: val = NEXTLONG (p); ! 427: fprintf (stream, "@#"); ! 428: print_address (val, stream); ! 429: break; ! 430: ! 431: case 2: ! 432: val = NEXTWORD (p); ! 433: print_address (addr + val, stream); ! 434: break; ! 435: ! 436: case 3: ! 437: p = print_indexed (-1, p, addr, stream); ! 438: break; ! 439: ! 440: case 4: ! 441: flt_p = 1; /* Assume it's a float... */ ! 442: switch( place ) ! 443: { ! 444: case 'b': ! 445: val = NEXTBYTE (p); ! 446: flt_p = 0; ! 447: break; ! 448: ! 449: case 'w': ! 450: val = NEXTWORD (p); ! 451: flt_p = 0; ! 452: break; ! 453: ! 454: case 'l': ! 455: val = NEXTLONG (p); ! 456: flt_p = 0; ! 457: break; ! 458: ! 459: case 'f': ! 460: flval = NEXTSINGLE(p); ! 461: break; ! 462: ! 463: case 'F': ! 464: flval = NEXTDOUBLE(p); ! 465: break; ! 466: ! 467: case 'x': ! 468: flval = NEXTEXTEND(p); ! 469: break; ! 470: ! 471: case 'p': ! 472: flval = NEXTPACKED(p); ! 473: break; ! 474: ! 475: default: ! 476: error ("Invalid arg format in opcode table: \"%c%c\".", ! 477: *d, place); ! 478: } ! 479: if ( flt_p ) /* Print a float? */ ! 480: fprintf (stream, "#%g", flval); ! 481: else ! 482: fprintf (stream, "#%d", val); ! 483: break; ! 484: ! 485: default: ! 486: fprintf (stream, "<invalid address mode 0%o>", val); ! 487: } ! 488: } ! 489: break; ! 490: ! 491: default: ! 492: error ("Invalid arg format in opcode table: \"%c\".", *d); ! 493: } ! 494: ! 495: return (unsigned char *) p; ! 496: } ! 497: ! 498: /* Fetch BITS bits from a position in the instruction specified by CODE. ! 499: CODE is a "place to put an argument", or 'x' for a destination ! 500: that is a general address (mode and register). ! 501: BUFFER contains the instruction. */ ! 502: ! 503: static int ! 504: fetch_arg (buffer, code, bits) ! 505: unsigned char *buffer; ! 506: char code; ! 507: int bits; ! 508: { ! 509: register int val; ! 510: switch (code) ! 511: { ! 512: case 's': ! 513: val = buffer[1]; ! 514: break; ! 515: ! 516: case 'd': /* Destination, for register or quick. */ ! 517: val = (buffer[0] << 8) + buffer[1]; ! 518: val >>= 9; ! 519: break; ! 520: ! 521: case 'x': /* Destination, for general arg */ ! 522: val = (buffer[0] << 8) + buffer[1]; ! 523: val >>= 6; ! 524: break; ! 525: ! 526: case 'k': ! 527: val = (buffer[3] >> 4); ! 528: break; ! 529: ! 530: case 'C': ! 531: val = buffer[3]; ! 532: break; ! 533: ! 534: case '1': ! 535: val = (buffer[2] << 8) + buffer[3]; ! 536: val >>= 12; ! 537: break; ! 538: ! 539: case '2': ! 540: val = (buffer[2] << 8) + buffer[3]; ! 541: val >>= 6; ! 542: break; ! 543: ! 544: case '3': ! 545: case 'j': ! 546: val = (buffer[2] << 8) + buffer[3]; ! 547: break; ! 548: ! 549: case '4': ! 550: val = (buffer[4] << 8) + buffer[5]; ! 551: val >>= 12; ! 552: break; ! 553: ! 554: case '5': ! 555: val = (buffer[4] << 8) + buffer[5]; ! 556: val >>= 6; ! 557: break; ! 558: ! 559: case '6': ! 560: val = (buffer[4] << 8) + buffer[5]; ! 561: break; ! 562: ! 563: case '7': ! 564: val = (buffer[2] << 8) + buffer[3]; ! 565: val >>= 7; ! 566: break; ! 567: ! 568: case '8': ! 569: val = (buffer[2] << 8) + buffer[3]; ! 570: val >>= 10; ! 571: break; ! 572: ! 573: default: ! 574: abort (); ! 575: } ! 576: ! 577: switch (bits) ! 578: { ! 579: case 3: ! 580: return val & 7; ! 581: case 4: ! 582: return val & 017; ! 583: case 5: ! 584: return val & 037; ! 585: case 6: ! 586: return val & 077; ! 587: case 7: ! 588: return val & 0177; ! 589: case 8: ! 590: return val & 0377; ! 591: case 12: ! 592: return val & 07777; ! 593: default: ! 594: abort (); ! 595: } ! 596: } ! 597: ! 598: /* Print an indexed argument. The base register is BASEREG (-1 for pc). ! 599: P points to extension word, in buffer. ! 600: ADDR is the nominal core address of that extension word. */ ! 601: ! 602: static unsigned char * ! 603: print_indexed (basereg, p, addr, stream) ! 604: int basereg; ! 605: unsigned char *p; ! 606: FILE *stream; ! 607: CORE_ADDR addr; ! 608: { ! 609: register int word; ! 610: static char *scales[] = {"", "*2", "*4", "*8"}; ! 611: register int base_disp; ! 612: register int outer_disp; ! 613: char buf[40]; ! 614: ! 615: word = NEXTWORD (p); ! 616: ! 617: /* Generate the text for the index register. ! 618: Where this will be output is not yet determined. */ ! 619: sprintf (buf, "[%s.%c%s]", ! 620: reg_names[(word >> 12) & 0xf], ! 621: (word & 0x800) ? 'l' : 'w', ! 622: scales[(word >> 9) & 3]); ! 623: ! 624: /* Handle the 68000 style of indexing. */ ! 625: ! 626: if ((word & 0x100) == 0) ! 627: { ! 628: print_base (basereg, ! 629: ((word & 0x80) ? word | 0xff00 : word & 0xff) ! 630: + ((basereg == -1) ? addr : 0), ! 631: stream); ! 632: fprintf (stream, "%s", buf); ! 633: return p; ! 634: } ! 635: ! 636: /* Handle the generalized kind. */ ! 637: /* First, compute the displacement to add to the base register. */ ! 638: ! 639: if (word & 0200) ! 640: basereg = -2; ! 641: if (word & 0100) ! 642: buf[0] = 0; ! 643: base_disp = 0; ! 644: switch ((word >> 4) & 3) ! 645: { ! 646: case 2: ! 647: base_disp = NEXTWORD (p); ! 648: break; ! 649: case 3: ! 650: base_disp = NEXTLONG (p); ! 651: } ! 652: if (basereg == -1) ! 653: base_disp += addr; ! 654: ! 655: /* Handle single-level case (not indirect) */ ! 656: ! 657: if ((word & 7) == 0) ! 658: { ! 659: print_base (basereg, base_disp, stream); ! 660: fprintf (stream, "%s", buf); ! 661: return p; ! 662: } ! 663: ! 664: /* Two level. Compute displacement to add after indirection. */ ! 665: ! 666: outer_disp = 0; ! 667: switch (word & 3) ! 668: { ! 669: case 2: ! 670: outer_disp = NEXTWORD (p); ! 671: break; ! 672: case 3: ! 673: outer_disp = NEXTLONG (p); ! 674: } ! 675: ! 676: fprintf (stream, "%d(", outer_disp); ! 677: print_base (basereg, base_disp, stream); ! 678: ! 679: /* If postindexed, print the closeparen before the index. */ ! 680: if (word & 4) ! 681: fprintf (stream, ")%s", buf); ! 682: /* If preindexed, print the closeparen after the index. */ ! 683: else ! 684: fprintf (stream, "%s)", buf); ! 685: ! 686: return p; ! 687: } ! 688: ! 689: /* Print a base register REGNO and displacement DISP, on STREAM. ! 690: REGNO = -1 for pc, -2 for none (suppressed). */ ! 691: ! 692: static void ! 693: print_base (regno, disp, stream) ! 694: int regno; ! 695: int disp; ! 696: FILE *stream; ! 697: { ! 698: if (regno == -2) ! 699: fprintf (stream, "%d", disp); ! 700: else if (regno == -1) ! 701: fprintf (stream, "0x%x", disp); ! 702: else ! 703: fprintf (stream, "%d(%s)", disp, reg_names[regno]); ! 704: } ! 705: ! 706: /* This is not part of insn printing, but it is machine-specific, ! 707: so this is a convenient place to put it. ! 708: ! 709: Convert a 68881 extended float to a double. ! 710: FROM is the address of the extended float. ! 711: Store the double in *TO. */ ! 712: ! 713: convert_from_68881 (from, to) ! 714: char *from; ! 715: double *to; ! 716: { ! 717: #ifdef HPUX_ASM ! 718: asm ("mov.l 8(%a6),%a0"); ! 719: asm ("mov.l 12(%a6),%a1"); ! 720: asm ("fmove.x (%a0),%fp0"); ! 721: asm ("fmove.d %fp0,(%a1)"); ! 722: #else /* not HPUX_ASM */ ! 723: #if 0 ! 724: asm ("movl a6@(8),a0"); ! 725: asm ("movl a6@(12),a1"); ! 726: asm ("fmovex a0@,fp0"); ! 727: asm ("fmoved fp0,a1@"); ! 728: #else ! 729: /* Hand-assemble those insns since some assemblers lose ! 730: and some have different syntax. */ ! 731: asm (".word 020156"); ! 732: asm (".word 8"); ! 733: asm (".word 021156"); ! 734: asm (".word 12"); ! 735: asm (".long 0xf2104800"); ! 736: asm (".long 0xf2117400"); ! 737: #endif ! 738: #endif /* not HPUX_ASM */ ! 739: } ! 740: ! 741: /* The converse: convert the double *FROM to an extended float ! 742: and store where TO points. */ ! 743: ! 744: convert_to_68881 (from, to) ! 745: double *from; ! 746: char *to; ! 747: { ! 748: #ifdef HPUX_ASM ! 749: asm ("mov.l 8(%a6),%a0"); ! 750: asm ("mov.l 12(%a6),%a1"); ! 751: asm ("fmove.d (%a0),%fp0"); ! 752: asm ("fmove.x %fp0,(%a1)"); ! 753: #else /* not HPUX_ASM */ ! 754: #if 0 ! 755: asm ("movl a6@(8),a0"); ! 756: asm ("movl a6@(12),a1"); ! 757: asm ("fmoved a0@,fp0"); ! 758: asm ("fmovex fp0,a1@"); ! 759: #else ! 760: /* Hand-assemble those insns since some assemblers lose. */ ! 761: asm (".word 020156"); ! 762: asm (".word 8"); ! 763: asm (".word 021156"); ! 764: asm (".word 12"); ! 765: asm (".long 0xf2105400"); ! 766: asm (".long 0xf2116800"); ! 767: #endif ! 768: #endif /* not HPUX_ASM */ ! 769: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.