Minix1.5/commands/dis88/disfp.c
static char *sccsid =
"@(#) disfp.c, Ver. 2.1 created 00:00:00 87/09/01";
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* Copyright (C) 1987 G. M. Harding, all rights reserved *
* *
* Permission to copy and redistribute is hereby granted, *
* provided full source code, with all copyright notices, *
* accompanies any redistribution. *
* *
* This file contains handler routines for the numeric op- *
* codes of the 8087 co-processor, as well as a few other *
* opcodes which are related to 8087 emulation. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
#include "dis.h" /* Disassembler declarations */
#define FPINT0 0xd8 /* Floating-point interrupts */
#define FPINT1 0xd9
#define FPINT2 0xda
#define FPINT3 0xdb
#define FPINT4 0xdc
#define FPINT5 0xdd
#define FPINT6 0xde
#define FPINT7 0xdf
/* Test for floating opcodes */
#define ISFLOP(x) \
(((x) >= FPINT0) && ((x) <= FPINT7))
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* This is the handler for the escape family of opcodes. *
* These opcodes place the contents of a specified memory *
* location on the system bus, for access by a peripheral *
* or by a co-processor such as the 8087. (The 8087 NDP is *
* accessed only via bus escapes.) Due to a bug in the *
* PC/IX assembler, the "esc" mnemonic is not recognized; *
* consequently, escape opcodes are disassembled as .byte *
* directives, with the appropriate mnemonic and operand *
* included as a comment. FOR NOW, those escape sequences *
* corresponding to 8087 opcodes are treated as simple *
* escapes. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void
eshand(j)
register int j; /* Pointer to optab[] entry */
{/* * * * * * * * * * START OF eshand() * * * * * * * * * */
register char *a;
register int k;
objini(j);
FETCH(k);
a = mtrans((j & 0xfd),(k & 0xc7),TR_STD);
mtrunc(a);
printf("\t.byte\t0x%02.2x\t\t| esc\t%s\n",j,a);
for (k = 1; k < objptr; ++k)
printf("\t.byte\t0x%02.2x\n",objbuf[k]);
}/* * * * * * * * * * * END OF eshand() * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* This is the handler routine for floating-point opcodes. *
* Since PC/IX must accommodate systems with and without *
* 8087 co-processors, it allows floating-point operations *
* to be initiated in either of two ways: by a software *
* interrput whose type is in the range 0xd8 through 0xdf, *
* or by a CPU escape sequence, which is invoked by an op- *
* code in the same range. In either case, the subsequent *
* byte determines the actual numeric operation to be per- *
* formed. However, depending on the method of access, *
* either one or two code bytes will precede that byte, *
* and the fphand() routine has no way of knowing whether *
* it was invoked by interrupt or by an escape sequence. *
* Therefore, unlike all of the other handler routines ex- *
* cept dfhand(), fphand() does not initialize the object *
* buffer, leaving that chore to the caller. *
* *
* FOR NOW, fphand() does not disassemble floating-point *
* opcodes to floating mnemonics, but simply outputs the *
* object code as .byte directives. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void
fphand(j)
register int j; /* Pointer to optab[] entry */
{/* * * * * * * * * * START OF fphand() * * * * * * * * * */
register int k;
segflg = 0;
FETCH(k);
printf("\t.byte\t0x%02.2x\t\t| 8087 code sequence\n",
objbuf[0]);
for (k = 1; k < objptr; ++k)
printf("\t.byte\t0x%02.2x\n",objbuf[k]);
/* objout(); FOR NOW */
}/* * * * * * * * * * * END OF fphand() * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* *
* This is the handler for variable software interrupt *
* opcodes. It is included in this file because PC/IX im- *
* plements its software floating-point emulation by means *
* of interrupts. Any interrupt in the range 0xd8 through *
* 0xdf is an NDP-emulation interrupt, and is specially *
* handled by the assembler. *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void
inhand(j)
register int j; /* Pointer to optab[] entry */
{/* * * * * * * * * * START OF inhand() * * * * * * * * * */
register int k;
objini(j);
FETCH(k);
if (ISFLOP(k))
{
fphand(k);
return;
}
printf("%s\t%d\n",optab[j].text,k);
objout();
}/* * * * * * * * * * * END OF inhand() * * * * * * * * * * */