Rivoreo Source Code Repositories
src.rivoreo.one / emulators / simh / df6475181c7f794e1c6885a048d5c1bd8b80605b / . / PDP11 / pdp11_cis.c
blob: 80a4bbf4dae1eab39129417fc7f7b6d8c86873c2 [file] [log] [blame] [raw]
/* pdp11_cis.c: PDP-11 CIS optional instruction set simulator
Copyright (c) 1993-2002, Robert M Supnik
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Except as contained in this notice, the name of Robert M Supnik shall not
be used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from Robert M Supnik.
This module simulates the PDP-11 commercial instruction set (CIS).
The commercial instruction set consists of three instruction formats:
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ register operands
| 0 1 1 1 1 1| 0 0 0 0| opcode | 076030:076057
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 076070:076077
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ inline operands
| 0 1 1 1 1 1| 0 0 0 1| opcode | 076130:076157
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 076170:076177
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ load descriptors
| 0 1 1 1 1 1| 0 0 0 0|op| 1 0| reg | 076020:076027
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ 076060:076067
The CIS instructions operate on character strings, packed (decimal)
strings, and numeric (decimal) strings. Strings are described by
a two word descriptor:
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| length in bytes | char string
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ descriptor
| starting byte address |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| |str type| | length | decimal string
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+ descriptor
| starting byte address |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
Decimal string types are:
<14:12> data type bytes occupied by n digits
0 signed zoned n
1 unsigned zone n
2 trailing overpunch n
3 leading overpunch n
4 trailing separate n+1
5 leading separate n+1
6 signed packed n/2 +1
7 unsigned packed n/2 +1
Zero length character strings occupy no memory; zero length decimal strings
require either zero bytes (zoned, overpunch) or one byte (separate, packed).
CIS instructions can run for a very long time, so they are interruptible
and restartable. In the simulator, all instructions run to completion.
The code is unoptimized.
*/
#include "pdp11_defs.h"
/* Opcode bits */
#define INLINE 0100 /* inline */
#define PACKED 0020 /* packed */
#define NUMERIC 0000 /* numeric */
/* Operand type definitions */
#define R0_DESC 1 /* descr in R0:R1 */
#define R2_DESC 2 /* descr in R2:R3 */
#define R4_DESC 3 /* descr in R4:R5 */
#define R4_ARG 4 /* argument in R4 */
#define IN_DESC 5 /* inline descriptor */
#define IN_ARG 6 /* inline argument */
#define IN_DESC_R0 7 /* inline descr to R0:R1 */
#define MAXOPN 4 /* max # operands */
/* Decimal data type definitions */
#define XZ 0 /* signed zoned */
#define UZ 1 /* unsigned zoned */
#define TO 2 /* trailing overpunch */
#define LO 3 /* leading overpunch */
#define TS 4 /* trailing separate */
#define LS 5 /* leading separate */
#define XP 6 /* signed packed */
#define UP 7 /* unsigned packed */
/* Decimal descriptor definitions */
#define DTYP_M 07 /* type mask */
#define DTYP_V 12 /* type position */
#define DLNT_M 037 /* length mask */
#define DLNT_V 0 /* length position */
#define GET_DTYP(x) (((x) >> DTYP_V) & DTYP_M)
#define GET_DLNT(x) (((x) >> DLNT_V) & DLNT_M)
/* Shift operand definitions */
#define ASHRND_M 017 /* round digit mask */
#define ASHRND_V 8 /* round digit pos */
#define ASHLNT_M 0377 /* shift count mask */
#define ASHLNT_V 0 /* shift length pos */
#define ASHSGN 0200 /* shift sign */
#define GET_ASHRND(x) (((x) >> ASHRND_V) & ASHRND_M)
#define GET_ASHLNT(x) (((x) >> ASHLNT_V) & ASHLNT_M)
/* Operand array aliases */
#define A1LNT arg[0]
#define A1ADR arg[1]
#define A2LNT arg[2]
#define A2ADR arg[3]
#define A3LNT arg[4]
#define A3ADR arg[5]
#define A1 &arg[0]
#define A2 &arg[2]
#define A3 &arg[4]
/* Condition code macros */
#define GET_BIT(ir,n) (((ir) >> n) & 1)
#define GET_SIGN_L(ir) GET_BIT((ir), 31)
#define GET_SIGN_W(ir) GET_BIT((ir), 15)
#define GET_SIGN_B(ir) GET_BIT((ir), 7)
#define GET_Z(ir) (ir == 0)
/* Decimal string structure */
#define DSTRLNT 4
#define DSTRMAX (DSTRLNT - 1)
#define MAXDVAL 429496730 /* 2^32 / 10 */
struct dstr {
unsigned int32 sign;
unsigned int32 val[DSTRLNT]; };
typedef struct dstr DSTR;
static DSTR Dstr0 = { 0, 0, 0, 0, 0 };
extern int32 isenable, dsenable;
extern int32 N, Z, V, C;
extern int32 R[8], trap_req;
extern int32 ReadW (int32 addr);
extern void WriteW (int32 data, int32 addr);
extern int32 ReadB (int32 addr);
extern void WriteB (int32 data, int32 addr);
int32 ReadDstr (int32 *dscr, DSTR *dec, int32 flag);
void WriteDstr (int32 *dscr, DSTR *dec, int32 flag);
int32 AddDstr (DSTR *src1, DSTR *src2, DSTR *dst, int32 cin);
void SubDstr (DSTR *src1, DSTR *src2, DSTR *dst);
int32 CmpDstr (DSTR *src1, DSTR *src2);
int32 TestDstr (DSTR *dsrc);
int32 LntDstr (DSTR *dsrc, int32 nz);
unsigned int32 NibbleLshift (DSTR *dsrc, int32 sc, unsigned int32 cin);
unsigned int32 NibbleRshift (DSTR *dsrc, int32 sc, unsigned int32 cin);
int32 WordLshift (DSTR *dsrc, int32 sc);
void WordRshift (DSTR *dsrc, int32 sc);
void CreateTable (DSTR *dsrc, DSTR mtable[10]);
/* Table of instruction operands */
static int32 opntab[128][MAXOPN] = {
0, 0, 0, 0, 0, 0, 0, 0, /* 000 - 007 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, /* 010 - 017 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, /* LD2R */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
R0_DESC, R2_DESC, R4_ARG, 0, /* MOVC */
R0_DESC, R2_DESC, R4_ARG, 0, /* MOVRC */
R0_DESC, R2_DESC, R4_DESC, 0, /* MOVTC */
0, 0, 0, 0, /* 033 */
0, 0, 0, 0, 0, 0, 0, 0, /* 034 - 037 */
0, 0, 0, 0, 0, 0, 0, 0,
R4_ARG, 0, 0, 0, /* LOCC */
R4_ARG, 0, 0, 0, /* SKPC */
R4_DESC, 0, 0, 0, /* SCANC */
R4_DESC, 0, 0, 0, /* SPANC */
R0_DESC, R2_DESC, R4_ARG, 0, /* CMPC */
R2_DESC, 0, 0, 0, /* MATC */
0, 0, 0, 0, 0, 0, 0, 0, /* 046 - 047 */
R0_DESC, R2_DESC, R4_DESC, 0, /* ADDN */
R0_DESC, R2_DESC, R4_DESC, 0, /* SUBN */
R0_DESC, R2_DESC, 0, 0, /* CMPN */
R0_DESC, 0, 0, 0, /* CVTNL */
R0_DESC, R2_DESC, 0, 0, /* CVTPN */
R0_DESC, R2_DESC, 0, 0, /* CVTNP */
R0_DESC, R2_DESC, R4_ARG, 0, /* ASHN */
R0_DESC, 0, 0, 0, /* CVTLN */
0, 0, 0, 0, 0, 0, 0, 0, /* LD3R */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
R0_DESC, R2_DESC, R4_DESC, 0, /* ADDP */
R0_DESC, R2_DESC, R4_DESC, 0, /* SUBP */
R0_DESC, R2_DESC, 0, 0, /* CMPP */
R0_DESC, 0, 0, 0, /* CVTPL */
R0_DESC, R2_DESC, R4_DESC, 0, /* MULP */
R0_DESC, R2_DESC, R4_DESC, 0, /* DIVP */
R0_DESC, R2_DESC, R4_ARG, 0, /* ASHP */
R0_DESC, 0, 0, 0, /* CVTLP */
0, 0, 0, 0, 0, 0, 0, 0, /* 100 - 107 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, /* 110 - 117 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, /* 120 - 127 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
IN_DESC, IN_DESC, IN_ARG, 0, /* MOVCI */
IN_DESC, IN_DESC, IN_ARG, 0, /* MOVRCI */
IN_DESC, IN_DESC, IN_ARG, IN_ARG, /* MOVTCI */
0, 0, 0, 0, /* 133 */
0, 0, 0, 0, 0, 0, 0, 0, /* 134 - 137 */
0, 0, 0, 0, 0, 0, 0, 0,
IN_DESC_R0, IN_ARG, 0, 0, /* LOCCI */
IN_DESC_R0, IN_ARG, 0, 0, /* SKPCI */
IN_DESC_R0, IN_DESC, 0, 0, /* SCANCI */
IN_DESC_R0, IN_DESC, 0, 0, /* SPANCI */
IN_DESC, IN_DESC, IN_ARG, 0, /* CMPCI */
IN_DESC_R0, IN_DESC, 0, 0, /* MATCI */
0, 0, 0, 0, 0, 0, 0, 0, /* 146 - 147 */
IN_DESC, IN_DESC, IN_DESC, 0, /* ADDNI */
IN_DESC, IN_DESC, IN_DESC, 0, /* SUBNI */
IN_DESC, IN_DESC, 0, 0, /* CMPNI */
IN_DESC, IN_ARG, 0, 0, /* CVTNLI */
IN_DESC, IN_DESC, 0, 0, /* CVTPNI */
IN_DESC, IN_DESC, 0, 0, /* CVTNPI */
IN_DESC, IN_DESC, IN_ARG, 0, /* ASHNI */
IN_DESC, IN_DESC, 0, 0, /* CVTLNI */
0, 0, 0, 0, 0, 0, 0, 0, /* 160 - 167 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
IN_DESC, IN_DESC, IN_DESC, 0, /* ADDPI */
IN_DESC, IN_DESC, IN_DESC, 0, /* SUBPI */
IN_DESC, IN_DESC, 0, 0, /* CMPPI */
IN_DESC, 0, 0, 0, /* CVTPLI */
IN_DESC, IN_DESC, IN_DESC, 0, /* MULPI */
IN_DESC, IN_DESC, IN_DESC, 0, /* DIVPI */
IN_DESC, IN_DESC, IN_ARG, 0, /* ASHPI */
IN_DESC, IN_DESC, 0, 0 /* CVTLPI */
};
/* ASCII to overpunch table: sign is <7>, digit is <4:0> */
static int32 overbin[128] = {
0, 0, 0, 0, 0, 0, 0, 0, /* 000 - 037 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0x80, 0, 0, 0, 0, 0, 0, /* 040 - 077 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7,
8, 9, 0x80, 0, 0, 0, 0, 0,
0, 1, 2, 3, 4, 5, 6, 7, /* 100 - 137 */
8, 9, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86,
0x87, 0x88, 0x89, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0x80, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, /* 140 - 177 */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0x80, 0, 0
};
/* Overpunch to ASCII table: indexed by sign and digit */
static int32 binover[2][16] = {
'{', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I',
'0', '0', '0', '0', '0', '0',
'}', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R',
'0', '0', '0', '0', '0', '0'
};
static unsigned char movbuf[65536];
/* CIS emulator */
void cis11 (int32 IR)
{
int32 c, i, j, k, t, op, rn, addr;
int32 fill, mask, match, limit, mvlnt, shift;
int32 spc, ldivd, ldivr;
int32 arg[6]; /* operands */
uint32 nc, digit, result;
static DSTR accum, src1, src2, dst;
static DSTR mptable[10];
static DSTR Dstr1 = { 0, 0x10, 0, 0, 0 };
op = IR & 0177; /* IR <6:0> */
for (i = j = 0; (i < MAXOPN) && opntab[op][i]; i++) { /* parse operands */
switch (opntab[op][i]) { /* case on op type */
case R0_DESC:
arg[j++] = R[0];
arg[j++] = R[1];
break;
case R2_DESC:
arg[j++] = R[2];
arg[j++] = R[3];
break;
case R4_DESC:
arg[j++] = R[4];
arg[j++] = R[5];
break;
case R4_ARG:
arg[j++] = R[4];
break;
case IN_DESC:
addr = ReadW (PC | isenable);
PC = (PC + 2) & 0177777;
arg[j++] = ReadW (addr | dsenable);
arg[j++] = ReadW (((addr + 2) & 0177777) | dsenable);
break;
case IN_DESC_R0:
addr = ReadW (PC | isenable);
PC = (PC + 2) & 0177777;
R[0] = ReadW (addr | dsenable);
R[1] = ReadW (((addr + 2) & 0177777) | dsenable);
break;
case IN_ARG:
arg[j++] = ReadW (PC | isenable);
PC = (PC + 2) & 0177777;
break; } /* end case */
} /* end for */
switch (op) { /* case on opcode */
default:
setTRAP (TRAP_ILL);
return;
/* MOVC, MOVTC, MOVCI, MOVTCI
Operands:
A1LNT, A1ADR = source string descriptor
A2LNT, A2ADR = dest string descriptor
A3LNT<7:0> = fill character
A3ADR = translation table address (MOVTC, MOVTCI only)
Condition codes:
NZVC = set from src.lnt - dst.lnt
Registers (MOVC, MOVTC only)
R0 = max (0, src.len - dst.len)
R1:R3 = 0
R4:R5 = unchanged
Notes:
- To avoid overlap problems, the entire source string is
buffered in movbuf. On a modern microprocessor, for most
string sizes, this will be handled in the on chip cache.
- If either the source or destination lengths are zero,
the move loops exit immediately.
- If the source length does not exceed the destination
length, the fill loop exits immediately.
*/
case 030: case 032: case 0130: case 0132:
mvlnt = (A1LNT < A2LNT)? A1LNT: A2LNT; /* calc move lnt */
for (i = 0; i < mvlnt; i++) {
movbuf[i] = ReadB (((A1ADR + i) & 0177777) | dsenable); }
for (i = 0; i < mvlnt; i++) {
t = movbuf[i];
if (op & 2) t = ReadB (((A3ADR + t) & 0177777) | dsenable);
WriteB (t, ((A2ADR + i) & 0177777) | dsenable); }
fill = A3LNT & 0377; /* do fill, if any */
for (i = mvlnt; i < A2LNT; i++) {
WriteB (fill, ((A2ADR + i) & 0177777) | dsenable); }
t = A1LNT - A2LNT; /* src.lnt - dst.lnt */
N = GET_SIGN_W (t); /* set cc's from diff */
Z = GET_Z (t);
V = GET_SIGN_W ((A1LNT ^ A2LNT) & (~A2LNT ^ t));
C = (A1LNT < A2LNT);
if ((op & INLINE) == 0) { /* if reg, set reg */
R[0] = C? 0: t & 0177777;
R[1] = R[2] = R[3] = 0;
R[4] = R[4] & 0377; }
return;
/* MOVRC, MOVRCI
Operands:
A1LNT, A1ADR = source string descriptor
A2LNT, A2ADR = dest string descriptor
A3LNT<7:0> = fill character
Condition codes:
NZVC = set from src.lnt - dst.lnt
Registers (MOVRC only)
R0 = max (0, src.len - dst.len)
R1:R3 = 0
R4:R5 = unchanged
Notes: see MOVC, MOVCI
*/
case 031: case 0131:
mvlnt = (A1LNT < A2LNT)? A1LNT: A2LNT; /* calc move lnt */
addr = A1ADR + A1LNT - mvlnt;
for (i = 0; i < mvlnt; i++) {
movbuf[i] = ReadB (((addr + i) & 0177777) | dsenable); }
addr = A2ADR + A2LNT - mvlnt;
for (i = 0; i < mvlnt; i++) {
WriteB (movbuf[i], ((addr + i) & 0177777) | dsenable); }
fill = A3LNT & 0377; /* do fill, if any */
for (i = mvlnt, j = 0; i < A2LNT; i++, j++) {
WriteB (fill, ((A2ADR + j) & 0177777) | dsenable); }
t = A1LNT - A2LNT; /* src.lnt - dst.lnt */
N = GET_SIGN_W (t); /* set cc's from diff */
Z = GET_Z (t);
V = GET_SIGN_W ((A1LNT ^ A2LNT) & (~A2LNT ^ t));
C = (A1LNT < A2LNT);
if ((op & INLINE) == 0) { /* if reg, set reg */
R[0] = C? 0: t & 0177777;
R[1] = R[2] = R[3] = 0;
R[4] = R[4] & 0377; }
return;
/* Load descriptors - no operands */
case 020: case 021: case 022: case 023:
case 024: case 025: case 026: case 027:
case 060: case 061: case 062: case 063:
case 064: case 065: case 066: case 067:
limit = (op & 040)? 6: 4;
rn = IR & 07; /* get register */
t = R[rn];
spc = (rn == 7)? isenable: dsenable;
for (j = 0; j < limit; j = j + 2) { /* loop for 2,3 dscr */
addr = ReadW (((t + j) & 0177777) | spc);
R[j] = ReadW (addr | dsenable);
R[j + 1] = ReadW (((addr + 2) & 0177777) | dsenable); }
if (rn >= limit) R[rn] = (R[rn] + limit) & 0177777;
return;
/* LOCC, SKPC, LOCCI, SKPCI
Operands:
R0, R1 = source string descriptor
A1LNT<7:0> = match character
Condition codes:
NZ = set from R0
VC = 0
Registers:
R0:R1 = substring descriptor where operation terminated
*/
case 040: case 041: case 0140: case 0141:
match = A1LNT & 0377; /* match character */
for ( ; R[0] != 0; R[0]--) { /* loop */
c = ReadB (R[1] | dsenable); /* get char */
if ((c == match) ^ (op & 1)) break; /* = + LOC, != + SKP? */
R[1] = (R[1] + 1) & 0177777; }
N = GET_SIGN_W (R[0]);
Z = GET_Z (R[0]);
V = C = 0;
if ((op & INLINE) == 0) R[4] = R[4] & 0377; /* if reg, set reg */
return;
/* SCANC, SPANC, SCANCI, SPANCI
Operands:
R0, R1 = source string descriptor
A1LNT<7:0> = mask
A1ADR = table address
Condition codes:
NZ = set from R0
VC = 0
Registers:
R0:R1 = substring descriptor where operation terminated
*/
case 042: case 043: case 0142: case 0143:
mask = A1LNT & 0377; /* mask character */
for (; R[0] != 0; R[0]--) { /* loop */
t = ReadB (R[1] | dsenable); /* get char as index */
c = ReadB (((A1ADR + t) & 0177777) | dsenable);
if (((c & mask) != 0) ^ (op & 1)) break; /* != + SCN, = + SPN? */
R[1] = (R[1] + 1) & 0177777; }
N = GET_SIGN_W (R[0]);
Z = GET_Z (R[0]);
V = C = 0;
if ((op & INLINE) == 0) R[4] = R[4] & 0377; /* if reg, set reg */
return;
/* CMPC, CMPCI
Operands:
A1LNT, A1ADR = source1 string descriptor
A2LNT, A2ADR = source2 string descriptor
A3LNT<7:0> = fill character
Condition codes:
NZVC = set from src1 - src2 at mismatch, or
= 0100 if equal
Registers (CMPC only):
R0:R1 = unmatched source1 substring descriptor
R2:R3 = unmatched source2 substring descriptor
*/
case 044: case 0144:
c = t = 0;
for (i = 0; i < ((A1LNT > A2LNT)? A1LNT: A2LNT); i++) {
if (i < A1LNT) c = ReadB (((A1ADR + i) & 0177777) | dsenable);
else c = A3LNT & 0377;
if (i < A2LNT) t = ReadB (((A2ADR + i) & 0177777) | dsenable);
else t = A3LNT & 0377;
if (c != t) break; }
j = c - t; /* last chars read */
N = GET_SIGN_B (j); /* set cc's */
Z = GET_Z (j);
V = GET_SIGN_B ((c ^ t) & (~t ^ j));
C = (c < t);
if ((op & INLINE) == 0) { /* if reg, set reg */
j = (i > A1LNT)? A1LNT: i; /* #src1 chars used */
k = (i > A2LNT)? A2LNT: i; /* #src2 chars used */
R[0] = A1LNT - j;
R[1] = (A1ADR + j) & 0177777;
R[2] = A2LNT - k;
R[3] = (A2ADR + k) & 0177777;
R[4] = R[4] & 0377; }
return;
/* MATC, MATCI
Operands:
R0, R1 = source string descriptor
A1LNT, A1ADR = substring descriptor
Condition codes:
NZ = set from R0
VC = 0
Registers:
R0:R1 = source substring descriptor for match
Notes:
- If the string is zero length, and the substring is not,
the outer loop exits immediately, and the result is
"no match"
- If the substring is zero length, the inner loop always
exits immediately, and the result is a "match"
- If the string is zero length, and the substring is as
well, the outer loop executes, the inner loop exits
immediately, and the result is a match, but the result
is the length of the string (zero), or "no match"
*/
case 0045: case 0145:
for (match = 0; R[0] >= A1LNT; R[0]--) { /* loop thru string */
for (i = 0, match = 1; match && (i < A1LNT); i++) {
c = ReadB (((R[1] + i) & 0177777) | dsenable);
t = ReadB (((A1ADR + i) & 0177777) | dsenable);
match = (c == t); } /* end for substring */
if (match) break; /* exit if match */
R[1] = (R[1] + 1) & 0177777; } /* end for string */
if (!match) { /* if no match */
R[1] = (R[1] + R[0]) & 0177777;
R[0] = 0; }
N = GET_SIGN_W (R[0]);
Z = GET_Z (R[0]);
V = C = 0;
return;
/* ADDN, SUBN, ADDP, SUBP, ADDNI, SUBNI, ADDPI, SUBPI
Operands:
A1LNT, A1ADR = source1 string descriptor
A2LNT, A2ADR = source2 string descriptor
A3LNT, A3ADR = destination string descriptor
Condition codes:
NZV = set from result
C = 0
Registers (ADDN, ADDP, SUBN, SUBP only):
R0:R3 = 0
*/
case 050: case 051: case 070: case 071:
case 0150: case 0151: case 0170: case 0171:
ReadDstr (A1, &src1, op); /* get source1 */
ReadDstr (A2, &src2, op); /* get source2 */
if (op & 1) src1.sign = src1.sign ^ 1; /* sub? invert sign */
if (src1.sign ^ src2.sign) { /* opp signs? sub */
if (CmpDstr (&src1, &src2) < 0) { /* src1 < src2? */
SubDstr (&src1, &src2, &dst); /* src2 - src1 */
dst.sign = src2.sign; } /* sign = src2 */
else { SubDstr (&src2, &src1, &dst); /* src1 - src2 */
dst.sign = src1.sign; } /* sign = src1 */
V = 0; } /* can't carry */
else { /* addition */
V = AddDstr (&src1, &src2, &dst, 0); /* add magnitudes */
dst.sign = src1.sign; } /* set result sign */
C = 0;
WriteDstr (A3, &dst, op); /* store result */
if ((op & INLINE) == 0) /* if reg, clr reg */
R[0] = R[1] = R[2] = R[3] = 0;
return;
/* MULP, MULPI
Operands:
A1LNT, A1ADR = source1 string descriptor
A2LNT, A2ADR = source2 string descriptor
A3LNT, A3ADR = destination string descriptor
Condition codes:
NZV = set from result
C = 0
Registers (MULP only):
R0:R3 = 0
*/
case 074: case 0174:
dst = Dstr0; /* clear result */
if (ReadDstr (A1, &src1, op) && ReadDstr (A2, &src2, op)) {
dst.sign = src1.sign ^ src2.sign; /* sign of result */
accum = Dstr0; /* clear accum */
NibbleRshift (&src1, 1, 0); /* shift out sign */
CreateTable (&src1, mptable); /* create *1, *2, ... */
for (i = 1; i < (DSTRLNT * 8); i++) { /* 31 iterations */
digit = (src2.val[i / 8] >> ((i % 8) * 4)) & 0xF;
if (digit > 0) /* add in digit*mpcnd */
AddDstr (&mptable[digit], &accum, &accum, 0);
nc = NibbleRshift (&accum, 1, 0); /* ac right 4 */
NibbleRshift (&dst, 1, nc); } /* result right 4 */
V = TestDstr (&accum) != 0; } /* if ovflo, set V */
else V = 0; /* result = 0 */
C = 0; /* C = 0 */
WriteDstr (A3, &dst, op); /* store result */
if ((op & INLINE) == 0) /* if reg, clr reg */
R[0] = R[1] = R[2] = R[3] = 0;
return;
/* DIVP, DIVPI
Operands:
A1LNT, A1ADR = divisor string descriptor
A2LNT, A2ADR = dividend string descriptor
A3LNT, A3ADR = destination string descriptor
Condition codes:
NZV = set from result
C = set if divide by zero
Registers (DIVP only):
R0:R3 = 0
*/
case 075: case 0175:
ldivr = ReadDstr (A1, &src1, op); /* get divisor */
if (ldivr == 0) { /* divisor = 0? */
V = C = 1; /* set cc's */
return; }
ldivr = LntDstr (&src1, ldivr); /* get exact length */
ldivd = ReadDstr (A2, &src2, op); /* get dividend */
ldivd = LntDstr (&src2, ldivd); /* get exact length */
dst = Dstr0; /* clear dest */
NibbleRshift (&src1, 1, 0); /* right justify ops */
NibbleRshift (&src2, 1, 0);
if ((t = ldivd - ldivr) >= 0) { /* any divide to do? */
WordLshift (&src1, t / 8); /* align divr to divd */
NibbleLshift (&src1, t % 8, 0);
CreateTable (&src1, mptable); /* create *1, *2, ... */
for (i = 0; i <= t; i++) { /* divide loop */
for (digit = 9; digit > 0; digit--) { /* find digit */
if (CmpDstr (&src2, &mptable[digit]) >= 0) {
SubDstr (&mptable[digit], &src2, &src2);
dst.val[0] = dst.val[0] | digit;
break; } } /* end if, for */
NibbleLshift (&src2, 1, 0); /* shift dividend */
NibbleLshift (&dst, 1, 0); /* shift quotient */
} /* end divide loop */
dst.sign = src1.sign ^ src2.sign; /* calculate sign */
} /* end if */
V = C = 0;
WriteDstr (A3, &dst, op); /* store result */
if ((op & INLINE) == 0) /* if reg, clr reg */
R[0] = R[1] = R[2] = R[3] = 0;
return;
/* CMPN, CMPP, CMPNI, CMPPI
Operands:
A1LNT, A1ADR = source1 string descriptor
A2LNT, A2ADR = source2 string descriptor
Condition codes:
NZ = set from comparison
VC = 0
Registers (CMPN, CMPP only):
R0:R3 = 0
*/
case 052: case 072: case 0152: case 0172:
ReadDstr (A1, &src1, op); /* get source1 */
ReadDstr (A2, &src2, op); /* get source2 */
N = Z = V = C = 0;
if (src1.sign != src2.sign) N = src1.sign;
else { t = CmpDstr (&src1, &src2); /* compare strings */
if (t < 0) N = 1;
else if (t == 0) Z = 1; }
if ((op & INLINE) == 0) /* if reg, clr reg */
R[0] = R[1] = R[2] = R[3] = 0;
return;
/* ASHN, ASHP, ASHNI, ASHPI
Operands:
A1LNT, A1ADR = source string descriptor
A2LNT, A2ADR = destination string descriptor
A3LNT<11:8> = rounding digit
A3LNT<7:0> = shift count
Condition codes:
NZV = set from result
C = 0
Registers (ASHN, ASHP only):
R0:R1, R4 = 0
*/
case 056: case 076: case 0156: case 0176:
ReadDstr (A1, &src1, op); /* get source */
V = C = 0; /* init cc's */
shift = GET_ASHLNT (A3LNT); /* get shift count */
if (shift & ASHSGN) { /* right shift? */
shift = (ASHLNT_M + 1 - shift); /* !shift! */
WordRshift (&src1, shift / 8); /* do word shifts */
NibbleRshift (&src1, shift % 8, 0); /* do nibble shifts */
t = GET_ASHRND (A3LNT); /* get rounding digit */
if ((t + (src1.val[0] & 0xF)) > 9) /* rounding needed? */
AddDstr (&src1, &Dstr1, &src1, 0); /* round */
src1.val[0] = src1.val[0] & ~0xF; /* clear sign */
} /* end right shift */
else if (shift) { /* left shift? */
if (WordLshift (&src1, shift / 8)) V = 1; /* do word shifts */
if (NibbleLshift (&src1, shift % 8, 0)) V = 1;
} /* end left shift */
WriteDstr (A2, &src1, op); /* store result */
if ((op & INLINE) == 0) /* if reg, clr reg */
R[0] = R[1] = R[4] = 0;
return;
/* CVTPN, CVTPNI
Operands:
A1LNT, A1ADR = source string descriptor
A2LNT, A2ADR = destination string descriptor
Condition codes:
NZV = set from result
C = 0
Registers (CVTPN only):
R0:R1 = 0
*/
case 054: case 0154:
ReadDstr (A1, &src1, PACKED); /* get source */
V = C = 0; /* init cc's */
WriteDstr (A2, &src1, NUMERIC); /* write dest */
if ((op & INLINE) == 0) R[0] = R[1] = 0; /* if reg, clr reg */
return;
/* CVTNP, CVTNPI
Operands:
A1LNT, A1ADR = source string descriptor
A2LNT, A2ADR = destination string descriptor
Condition codes:
NZV = set from result
C = 0
Registers (CVTNP only):
R0:R1 = 0
*/
case 055: case 0155:
ReadDstr (A1, &src1, NUMERIC); /* get source */
V = C = 0; /* init cc's */
WriteDstr (A2, &src1, PACKED); /* write dest */
if ((op & INLINE) == 0) R[0] = R[1] = 0; /* if reg, clr reg */
return;
/* CVTNL, CVTPL, CVTNLI, CVTPLI
Operands:
A1LNT, A1ADR = source string descriptor
A2LNT = destination address (inline only)
Condition codes:
NZV = set from result
C = source < 0 and result != 0
Registers (CVTNL, CVTPL only):
R0:R1 = 0
R2:R3 = result
*/
case 053: case 073: case 0153: case 0173:
ReadDstr (A1, &src1, op); /* get source */
V = result = 0; /* clear V, result */
for (i = (DSTRLNT * 8) - 1; i > 0; i--) { /* loop thru digits */
digit = (src1.val[i / 8] >> ((i % 8) * 4)) & 0xF;
if (digit || result || V) { /* skip initial 0's */
if (result >= MAXDVAL) V = 1;
result = (result * 10) + digit;
if (result < digit) V = 1; } /* end if */
} /* end for */
if (src1.sign) result = (~result + 1) & 0xFFFFFFFF;
N = GET_SIGN_L (result);
Z = GET_Z (result);
V = V | (N ^ src1.sign); /* overflow if +2**31 */
C = src1.sign && (Z == 0); /* set C based on std */
if (op & INLINE) { /* inline? */
WriteW (result & 0177777, A2LNT | dsenable);
WriteW ((result >> 16) & 0177777,
((A2LNT + 2) & 0177777) | dsenable); }
else { R[0] = R[1] = 0;
R[2] = (result >> 16) & 0177777;
R[3] = result & 0177777; }
return;
/* CVTLN, CVTLP, CVTLNI, CVTLPI
Operands:
A1LNT, A1ADR = destination string descriptor
A2LNT, A2ADR = source long (CVTLNI, CVTLPI) - VAX format
R2:R3 = source long (CVTLN, CVTLP) - EIS format
Condition codes:
NZV = set from result
C = 0
Registers (CVTLN, CVTLP only)
R2:R3 = 0
*/
case 057: case 077:
result = (R[2] << 16) | R[3]; /* op in EIS format */
R[2] = R[3] = 0; /* clear registers */
goto CVTLx; /* join common code */
case 0157: case 0177:
result = (A2ADR << 16) | A2LNT; /* op in VAX format */
CVTLx:
dst = Dstr0; /* clear result */
if (dst.sign = GET_SIGN_L (result)) result = (~result + 1) & 0xFFFFFFFF;
for (i = 1; (i < (DSTRLNT * 8)) && result; i++) {
digit = result % 10;
result = result / 10;
dst.val[i / 8] = dst.val[i / 8] | (digit << ((i % 8) * 4)); }
V = C = 0;
WriteDstr (A1, &dst, op); /* write result */
return; }
return;
} /* end cis */
/* Get decimal string
Arguments:
dscr = decimal string descriptor
src = decimal string structure
flag = numeric/packed flag
The routine returns the length in int32's of the non-zero part of
the string.
This routine plays fast and loose with operand checking, as did the
original 11/23 microcode (half of which I wrote). In particular,
- If the flag specifies packed, the type is not checked at all.
The sign of an unsigned string is assumed to be 0xF (an
alternative for +).
- If the flag specifies numeric, packed types will be treated
as unsigned zoned.
- For separate, only the '-' sign is checked, not the '+'.
However, to simplify the code elsewhere, digits are range checked,
and bad digits are replaced with 0's.
*/
int32 ReadDstr (int32 *dscr, DSTR *src, int32 flag)
{
int32 c, i, end, lnt, type, t;
*src = Dstr0; /* clear result */
type = GET_DTYP (dscr[0]); /* get type */
lnt = GET_DLNT (dscr[0]); /* get string length */
if (flag & PACKED) { /* packed? */
end = lnt / 2; /* last byte */
for (i = 0; i <= end; i++) { /* loop thru string */
c = ReadB (((dscr[1] + end - i) & 0177777) | dsenable);
if (i == 0) t = c & 0xF; /* save sign */
if ((i == end) && ((lnt & 1) == 0)) c = c & 0xF;
if (c >= 0xA0) c = c & 0xF; /* check hi digit */
if ((c & 0xF) >= 0xA) c = c & 0xF0; /* check lo digit */
src -> val[i / 4] = src -> val[i / 4] | (c << ((i % 4) * 8));
} /* end for */
if ((t == 0xB) || (t == 0xD)) src -> sign = 1; /* if -, set sign */
src -> val[0] = src -> val[0] & ~0xF; /* clear sign */
} /* end packed */
else { /* numeric */
if (type >= TS) src -> sign = (ReadB ((((type == TS)?
dscr[1] + lnt: dscr[1] - 1) & 0177777) | dsenable) == '-');
for (i = 1; i <= lnt; i++) { /* loop thru string */
c = ReadB (((dscr[1] + lnt - i) & 0177777) | dsenable);
if ((i == 1) && (type == XZ) && ((c & 0xF0) == 0x70))
src -> sign = 1; /* signed zoned */
else if (((i == 1) && (type == TO)) ||
((i == lnt) && (type == LO))) {
c = overbin[c & 0177]; /* get sign and digit */
src -> sign = c >> 7; } /* set sign */
c = c & 0xF; /* get digit */
if (c > 9) c = 0; /* range check */
src -> val[i / 8] = src -> val[i / 8] | (c << ((i % 8) * 4));
} /* end for */
} /* end numeric */
return TestDstr (src); /* clean -0 */
}
/* Store decimal string
Arguments:
dsrc = decimal string descriptor
src = decimal string structure
flag = numeric/packed flag
PSW.NZ are also set to their proper values
PSW.V will be set on overflow; it must be initialized elsewhere
(to allow for external overflow calculations)
The rules for the stored sign and the PSW sign are:
- Stored sign is negative if input is negative, string type
is signed, and the result is non-zero or there was overflow
- PSW sign is negative if input is negative, string type is
signed, and the result is non-zero
Thus, the stored sign and the PSW sign will differ in one case:
a negative zero generated by overflow is stored with a negative
sign, but PSW.N is clear
*/
void WriteDstr (int32 *dscr, DSTR *dst, int32 flag)
{
int32 c, i, limit, end, type, lnt;
uint32 mask;
static uint32 masktab[8] = {
0xFFFFFFF0, 0xFFFFFF00, 0xFFFFF000, 0xFFFF0000,
0xFFF00000, 0xFF000000, 0xF0000000, 0x00000000 };
static int32 unsignedtab[8] = { 0, 1, 0, 0, 0, 0, 0, 1 };
type = GET_DTYP (dscr[0]); /* get type */
lnt = GET_DLNT (dscr[0]); /* get string length */
mask = 0; /* can't ovflo */
Z = 1; /* assume all 0's */
limit = lnt / 8; /* limit for test */
for (i = 0; i < DSTRLNT; i++) { /* loop thru value */
if (i == limit) mask = masktab[lnt % 8]; /* at limit, get mask */
else if (i > limit) mask = 0xFFFFFFFF; /* beyond, all ovflo */
if (dst -> val[i] & mask) V = 1; /* test for ovflo */
if (dst -> val[i] = dst -> val[i] & ~mask) Z = 0; } /* test nz */
dst -> sign = dst -> sign & ~unsignedtab[type] & ~(Z & ~V);
N = dst -> sign & ~Z; /* N = sign, if ~zero */
if (flag & PACKED) { /* packed? */
end = lnt / 2; /* end of string */
if (type == UP) dst -> val[0] = dst -> val[0] | 0xF;
else dst -> val[0] = dst -> val[0] | 0xC | dst -> sign;
for (i = 0; i <= end; i++) { /* store string */
c = (dst -> val[i / 4] >> ((i % 4) * 8)) & 0xFF;
WriteB (c, ((dscr[1] + end - i) & 0177777));
} /* end for */
} /* end packed */
else {
if (type >= TS) WriteB (dst -> sign? '-': '+', (((type == TS)?
dscr[1] + lnt: dscr[1] - 1) & 0177777) | dsenable);
for (i = 1; i <= lnt; i++) { /* store string */
c = (dst -> val[i / 8] >> ((i % 8) * 4)) & 0xF; /* get digit */
if ((i == 1) && (type == XZ) && dst -> sign)
c = c | 0x70; /* signed zoned */
else if (((i == 1) && (type == TO)) ||
((i == lnt) && (type == LO)))
c = binover[dst -> sign][c]; /* get sign and digit */
else c = c | 0x30; /* default */
WriteB (c, ((dscr[1] + lnt - i) & 0177777));
} /* end for */
} /* end numeric */
return;
}
/* Add decimal string magnitudes
Arguments:
s1 = source1 decimal string
s2 = source2 decimal string
ds = destination decimal string
cy = carry in
Output = 1 if carry, 0 if no carry
This algorithm courtesy Anton Chernoff, circa 1992 or even earlier
We trace the history of a pair of adjacent digits to see how the
carry is fixed; each parenthesized item is a 4b digit.
Assume we are adding:
(a)(b) I
+ (x)(y) J
First compute I^J:
(a^x)(b^y) TMP
Note that the low bit of each digit is the same as the low bit of
the sum of the digits, ignoring the cary, since the low bit of the
sum is the xor of the bits.
Now compute I+J+66 to get decimal addition with carry forced left
one digit:
(a+x+6+carry mod 16)(b+y+6 mod 16) SUM
Note that if there was a carry from b+y+6, then the low bit of the
left digit is different from the expected low bit from the xor.
If we xor this SUM into TMP, then the low bit of each digit is 1
if there was a carry, and 0 if not. We need to subtract 6 from each
digit that did not have a carry, so take ~(SUM ^ TMP) & 0x11, shift
it right 4 to the digits that are affected, and subtract 6*adjustment
(actually, shift it right 3 and subtract 3*adjustment).
*/
int32 AddDstr (DSTR *s1, DSTR *s2, DSTR *ds, int32 cy)
{
int32 i;
unsigned int32 sm1, sm2, tm1, tm2, tm3, tm4;
for (i = 0; i < DSTRLNT; i++) { /* loop low to high */
tm1 = s1 -> val[i] ^ (s2 -> val[i] + cy); /* xor operands */
sm1 = s1 -> val[i] + (s2 -> val[i] + cy); /* sum operands */
sm2 = sm1 + 0x66666666; /* force carry out */
cy = ((sm1 < s1 -> val[i]) || (sm2 < sm1)); /* check for overflow */
tm2 = tm1 ^ sm2; /* get carry flags */
tm3 = (tm2 >> 3) | (cy << 29); /* compute adjustment */
tm4 = 0x22222222 & ~tm3; /* clear where carry */
ds -> val[i] = sm2 - (3 * tm4); } /* final result */
return cy;
}
/* Subtract decimal string magnitudes
Arguments:
s1 = source1 decimal string
s2 = source2 decimal string
ds = destination decimal string
Outputs: s2 - s1 in ds
Note: the routine assumes that s1 <= s2
*/
void SubDstr (DSTR *s1, DSTR *s2, DSTR *ds)
{
int32 i;
DSTR compl;
for (i = 0; i < DSTRLNT; i++) compl.val[i] = 0x99999999 - s1 -> val[i];
AddDstr (&compl, s2, ds, 1); /* s1 + ~s2 + 1 */
return;
}
/* Compare decimal string magnitudes
Arguments:
s1 = source1 decimal string
s2 = source2 decimal string
Output = 1 if >, 0 if =, -1 if <
*/
int32 CmpDstr (DSTR *s1, DSTR *s2)
{
int32 i;
for (i = DSTRMAX; i >=0; i--) {
if (s1 -> val[i] > s2 -> val[i]) return 1;
if (s1 -> val[i] < s2 -> val[i]) return -1; }
return 0;
}
/* Test decimal string for zero
Arguments:
dsrc = decimal string structure
Returns the non-zero length of the string, in int32 units
If the string is zero, the sign is cleared
*/
int32 TestDstr (DSTR *dsrc)
{
int32 i;
for (i = DSTRMAX; i >= 0; i--) if (dsrc -> val[i]) return (i + 1);
dsrc -> sign = 0;
return 0;
}
/* Get exact length of decimal string
Arguments:
dsrc = decimal string structure
nz = result from TestDstr
*/
int32 LntDstr (DSTR *dsrc, int32 nz)
{
int32 i;
for (i = 7; i > 0; i--) {
if ((dsrc -> val[nz - 1] >> (i * 4)) & 0xF) break; }
return ((nz - 1) * 8) + i;
}
/* Create table of multiples
Arguments:
dsrc = base decimal string structure
mtable[10] = array of decimal string structures
Note that dsrc has a high order zero nibble; this
guarantees that the largest multiple won't overflow
Also note that mtable[0] is not filled in
*/
void CreateTable (DSTR *dsrc, DSTR mtable[10])
{
int32 (i);
mtable[1] = *dsrc;
for (i = 2; i < 10; i++) AddDstr (&mtable[1], &mtable[i-1], &mtable[i], 0);
return;
}
/* Word shift right
Arguments:
dsrc = decimal string structure
sc = shift count
*/
void WordRshift (DSTR *dsrc, int32 sc)
{
int32 i;
if (sc) {
for (i = 0; i < DSTRLNT; i++) {
if ((i + sc) < DSTRLNT) dsrc -> val[i] = dsrc -> val[i + sc];
else dsrc -> val[i] = 0; } }
return;
}
/* Word shift left
Arguments:
dsrc = decimal string structure
sc = shift count
*/
int32 WordLshift (DSTR *dsrc, int32 sc)
{
int32 i, c;
c = 0;
if (sc) {
for (i = DSTRMAX; i >= 0; i--) {
if (i > (DSTRMAX - sc)) c = c | dsrc -> val[i];
if ((i - sc) >= 0) dsrc -> val[i] = dsrc -> val[i - sc];
else dsrc -> val[i] = 0; } }
return c;
}
/* Nibble shift decimal string right
Arguments:
dsrc = decimal string structure
sc = shift count
cin = carry in
*/
unsigned int32 NibbleRshift (DSTR *dsrc, int32 sc, unsigned int32 cin)
{
int32 i, s, rs, nc;
if (s = sc * 4) {
rs = 32 - s;
for (i = DSTRMAX; i >= 0; i--) {
nc = dsrc -> val[i];
dsrc -> val[i] = ((dsrc -> val[i] >> s) |
(cin << rs)) & 0xFFFFFFFF;
cin = nc; }
return cin; }
return 0;
}
/* Nibble shift decimal string left
Arguments:
dsrc = decimal string structure
sc = shift count
cin = carry in
*/
unsigned int32 NibbleLshift (DSTR *dsrc, int32 sc, unsigned int32 cin)
{
int32 i, s, rs, nc;
if (s = sc * 4) {
rs = 32 - s;
for (i = 0; i < DSTRLNT; i++) {
nc = dsrc -> val[i];
dsrc -> val[i] = ((dsrc -> val[i] << s) |
(cin >> rs)) & 0xFFFFFFFF;
cin = nc; }
return cin; }
return 0;
}