/* s3_cpu.c: IBM System/3 CPU simulator
Copyright (c) 2001-2012, Charles E. Owen
HPL & SLC instruction code Copyright (c) 2001 by Henk Stegeman
Decimal Arithmetic Copyright (c) 2000 by Roger Bowler
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 Charles E. Owen shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from Charles E. Owen.
------------------------------------------------------------------------------
cpu System/3 (models 10 and 15) central processor
19-Mar-12 RMS Changed int to int32 in declarations (Mark Pizzolato)
The IBM System/3 was a popular small-business computing system introduced
in 1969 as an entry-level system for businesses that could not afford
the lowest rungs of the System/360. Its architecture is inspired by and
in some ways similar to the 360, but to save cost the instruction set is
much smaller and the I/O channel system greatly simplified. There is no
compatibilty between the two systems.
The original System/3 had two models, 6 and 10, and these came in two
configurations: card system and disk system. The unique feature of
the /3 was the use of 96-column cards, although traditional 80-column
cards were supprted also via attachment of a 1442 reader/punch.
System/3 is a batch-oriented system, controlled by an operating
system known as SCP (System Control Program), with it's own job control
language known as OCL (simpler and more logical than the JCL used on
the mainframes). Original models did not support multiprogramming
or any form of interactivity. (There was a hardware dual-program
facility available on the model 10 at the high end).
The line grew throughout the 1970s, overlapping the low end of the 360
line with the introduction of the model 15. The 15 (and later larger
variations of the model 12) broke the 64K limit designed in the original
models by adding a simple address translation unit to support up to 512K
bytes. The model 15 added a system of storage protection and allowed
multiprogramming in up to 3 partitions. Communications were added to
allow support of multiple 3270 terminals and the models 12 and 15 broke
the batch orientation and facilitated interactive use via the CCP
(communications control program). The System/3 was effectively replaced
by the much easier to manage and use System/34 and System/36 at the
low and middle of the range, and by System/370 or System/38 at the
high end.
This simulator implements the model 10 and model 15. Models 4, 6,
8, and 12 are not supported (these were technical variations on the
design which offered no functionality not present on either 10 or 15).
The System/3 is a byte-oriented machine with a data path of 8 bits
in all models, and an address width of 16 bits.
The register state for the System/3 CPU is:
BAR <0:15> Operand 1 address register
AAR <0:15> Operand 2 address register
XR1 <0:15> Index Register 1
XR2 <0:15> Index Register 2
PSR <0:15> Condition Register
IAR [0:9]<0:15> Instruction Address Register (p1, p2, plus 1 for each interrupt)
ARR [0:9]<0:15> Address Recall Register (p1, p2, plus 1 for each interrupt)
(The P2 IAR & ARR are used for the Dual Program feature)
Instruction formats follow the same basic pattern: a 1-byte opcode, a
1-byte "Q byte", and one or two addresses following in a format defined
by the first 4 bits of the opcode:
Op Code Q Byte Address(es)
0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7
+--+--+--+--+--+--+--+--+ +--+--+--+--+--+--+--+--+ +--+--+--+--+--+--+--...
| A 1 | A 2 | operation | | (defined by operation)| | Format based on A1, A2
+--+--+--+--+--+--+--+--+ +--+--+--+--+--+--+--+--+ +--+--+--+--+--+--+--...
{ --- } <---------------- Bits 00 = Operand 2 specified by 2-byte direct addr
Bits 01 = Operand 2 is 1-byte displacement + XR1
Bits 10 = Operand 2 is 1-byte displacement + XR2
Bits 11 = Operand 2 is not used
{ --- } <---------------------- Bits 00 = Operand 1 specified by 2-byte direct addr
Bits 01 = Operand 1 is 1-byte displacement + XR1
Bits 10 = Operand 1 is 1-byte displacement + XR2
Bits 11 = Operand 1 is not used
Instructions come in 3 basic formats, of varying lengths which are determined
by the top 4 bits of opcode defined above. Minimum instruction length is 3 bytes,
maximum is 6.
1) Command Format (Bits 0-3 are 1111):
+------------+ +------------+ +------------+
| Opcode | | Q-byte | | R-byte +
+------------+ +------------+ +------------+
(The meaning of Q-byte and R-byte defined by the operation)
2) One Address Instructions (either bits 0-1 or bits 2-3 are 01):
Direct Addressing Format:
+------------+ +------------+ +-----------+----------+
| Opcode | | Q-byte | | MSB + LSB +
+------------+ +------------+ +-----------+----------+
Base-Displacement Format:
+------------+ +------------+ +------------+
| Opcode | | Q-byte | |displacement+
+------------+ +------------+ +------------+
Opcodes are 0011xxxx or 1100xxxx.
Q-byte can be: 1) An immediate operand
2) A mask
3) A branch condition
4) A data selection
2) Two Address Instructions (neither bits 0-1 nor bits 2-3 are both 11):
Operand 1 Address Direct (opcodes 0001 or 0010):
+------------+ +------------+ +----------+----------+ +------------+
| Opcode | | Q-byte | | MSB + LSB + |displacement|
+------------+ +------------+ +----------+----------+ +------------+
Operand 2 Address Direct (opcodes 0100 or 1000):
+------------+ +------------+ +------------+ +----------+----------+
| Opcode | | Q-byte | |displacement| | MSB + LSB +
+------------+ +------------+ +------------+ +----------+----------+
Both Addresses Direct (opcode 0000):
+------------+ +------------+ +----------+----------+ +-----------+----------+
| Opcode | | Q-byte | | MSB + LSB + + MSB + LSB +
+------------+ +------------+ +----------+----------+ +-----------+----------+
Both Addresses Displacement (opcodes 0101, 0110, 1001, or 1010):
+------------+ +------------+ +------------+ +------------+
| Opcode | | Q-byte | |displacement| |displacement|
+------------+ +------------+ +------------+ +------------+
Assembler Mnemonic Format
-------------------------
The assembler format contains the same elements as the machine language operation,
but not always in the same format. The operation code frequently specifies both
the opcode and the Q byte, and the top nybble of the opcode is determined by
the format of the addresses.
Addresses take two forms: the direct address in hex, or a relative address
specified thusly: (byte,XRx) where 'byte' is a 1-byte offset, and XRx is
either XR1 or XR2 for the two index registers. Use these formats when
'address' is indicated below:
When 'reg' is mentioned, a mnemonic may be used for the register, thusly:
IAR Instruction Address Register for the current program level
ARR Address Recall Register for the current program level
P1IAR IAR for Program Level 1
P2IAR IAR for Program Level 2
PSR Program Status Register
0x01 - Equal
0x02 - Low
0x04 - High
0x08 - Decimal overflow
0x10 - Test false
0x20 - Binary overflow
0x40 - Not used
0x80 - Not used
XR1 Index Register 1
XR2 Index Register 2
IARx IAR for the interrupt level x (x = 0 thru 7)
All other operands mentioned below are single-byte hex, except for the
length (len) operand of the two-address instructions, which is a decimal length
in the range 1-256.
No-address formats:
------------------
HPL hex,hex Halt Program Level, the operands are the Q and R bytes
One-address formats:
-------------------
A reg,address Add to register
CLI address,byte Compare Logical Immediate
MVI address,byte Move Immediate
TBF address,mask Test Bits Off
TBN address,mask Test Bits On
SBF address,mask Set Bits Off
SBN address,mask Set Bits On
ST reg,address Store Register
L reg,address Load Register
LA reg,address Load Address
JC address,cond Jump on Condition
BC address,cond Branch on Condition
These operations do not specify a qbyte, it is implicit in the opcode:
B address Unconditional branch to address
BE address Branch Equal
BNE address Branch Not Equal
BH address Branch High
BNH address Branch Not High
BL address Branch Low
BNL address Branch Not Low
BT address Branch True
BF address Branch False
BP address Branch Plus
BM address Branch Minus
BNP address Branch Not Plus
BNM address Branch Not Minus
BZ address Branch Zero
BNZ address Branch Not Zero
BOZ address Branch Overflow Zoned
BOL address Branch Overflow Logical
BNOZ address Branch No Overflow Zoned
BNOL address Branch No Overflow Logical
NOPB address No - never jump
(substitute J for B above for a set of Jumps -- 1-byte operand (not 2),
always jumps forward up to 255 bytes. In this case, 'address' cannot be
less than the current address, nor greater than the current address + 255)
Two-address formats (first address is destination, len is decimal 1-256):
-------------------
MVC address,address,len Move Characters
CLC address,address,len Compare Logical Characters
ALC address,address,len Add Logical Characters
SLC address,address,len Subtract Logical Characters
ED address,address,len Edit
ITC address,address,len Insert and Test Characters
AZ address,address,len Add Zoned Decimal
SZ address,address,len Subtract Zoned Decimal
MNN address,address Move Numeric to Numeric
MNZ address,address Move Numeric to Zone
MZZ address,address Move Zone to Zone
MZN address,address Move Zone to Numeric
I/O Format
----------
In the I/O format, there are always 3 fields:
da - Device Address 0-15 (decimal)
m - Modifier 0-1
n - Function 0-7
The meaning of these is entirely defined by the device addressed.
There may be an optional control byte, or an optional address (based on
the type of instruction).
SNS da,m,n,address Sense I/O
LIO da,m,n,address Load I/O
TIO da,m,n,address Test I/O
SIO da,m,n,cc Start I/O -- cc is a control byte
APL da,m,n Advance Program Level
---------------------------------------------
Here is a handy opcode cross-reference table:
---------------------------------------------
| x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF
---+------------------------------------------------------------------
0x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
1x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
2x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
3x | SNS LIO - - ST L A - TBN TBF SBN SBF MVI CLI - -
|
4x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
5x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
6x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
7x | SNS LIO - - ST L A - TBN TBF SBN SBF MVI CLI - -
|
8x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
9x | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
Ax | - - - - ZAZ - AZ SZ MVX - ED ITC MVC CLC ALC SLC
Bx | SNS LIO - - ST L A - TBN TBF SBN SBF MVI CLI - -
|
Cx | BC TIO LA - - - - - - - - - - - - -
Dx | BC TIO LA - - - - - - - - - - - - -
Ex | BC TIO LA - - - - - - - - - - - - -
Fx | HPL APL JC SIO - - - - - - - - - - - -
This routine is the instruction decode routine for System/3.
It is called from the simulator control program to execute
instructions in simulated memory, starting at the simulated PC.
It runs until 'reason' is set non-zero.
General notes:
1. Reasons to stop. The simulator can be stopped by:
HALT instruction
breakpoint encountered
program check caused by invalid opcode or qbyte or address or I/O spec
unknown I/O device and STOP_DEV flag set
I/O error in I/O simulator
2. Interrupts.
There are 8 levels of interrupt, each with it's own IAR (program
counter). When an interrupt occurs, execution begins at the
location in the IAR for that level interrupt. The program
must save and restore state. Each device is assigned both a
level and a priority in hardware. Interrupts are reset via
an SIO instruction, when this happens, the program level
IAR resumes control.
Interrupts are maintained in the global variable int_req,
which is zero if no interrupts are pending, otherwise, the
lower 16 bits represent devices, rightmost bit being device
0. Each device requesting an interrupt sets its bit on.
3. Non-existent memory. On the System/3, any reference to non-existent
memory (read or write) causes a program check and machine stop.
4. Adding I/O devices. These modules must be modified:
ibms3_defs.h add interrupt request definition
ibms3_cpu.c add IOT mask, PI mask, and routine to dev_table
ibms3_sys.c add pointer to data structures to sim_devices
*/
#include "s3_defs.h"
#define UNIT_V_M15 (UNIT_V_UF) /* Model 15 extensions */
#define UNIT_M15 (1 << UNIT_V_M15)
#define UNIT_V_DPF (UNIT_V_UF+1) /* Dual Programming */
#define UNIT_DPF (1 << UNIT_V_DPF)
#define UNIT_V_MSIZE (UNIT_V_UF+3) /* dummy mask */
#define UNIT_MSIZE (1 << UNIT_V_MSIZE)
uint8 M[MAXMEMSIZE] = { 0 }; /* memory */
int32 AAR = 0; /* Operand 1 addr reg */
int32 BAR = 0; /* Operand 2 addr reg */
int32 XR1 = 0; /* Index register 1 */
int32 XR2 = 0; /* Index register 2 */
int32 PSR = 0; /* Condition Register */
int32 IAR[10] = { 0 }; /* IAR 0-7 = int level 8=P1 9=P2 */
int32 ARR[10] = { 0 }; /* ARR 0-7 = int level 8=P1 9=P2 */
int32 dev_disable = 0; /* interrupt disable mask */
int32 int_req = 0; /* Interrupt request device bitmap */
int32 level = 8; /* Current Execution Level*/
int32 stop_dev = 0; /* stop on ill dev */
int32 SR = 0; /* Switch Register */
int32 saved_PC; /* Saved (old) PC) */
int32 debug_reg = 0; /* set for debug/trace */
int32 debug_flag = 0; /* 1 when trace.log open */
FILE *trace;
t_stat cpu_ex (t_value *vptr, t_addr addr, UNIT *uptr, int32 sw);
t_stat cpu_dep (t_value val, t_addr addr, UNIT *uptr, int32 sw);
t_stat cpu_reset (DEVICE *dptr);
t_stat cpu_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc);
t_stat cpu_boot (int32 unitno, DEVICE *dptr1);
extern int32 pkb (int32 op, int32 m, int32 n, int32 data);
extern int32 crd (int32 op, int32 m, int32 n, int32 data);
extern int32 lpt (int32 op, int32 m, int32 n, int32 data);
extern int32 dsk1 (int32 op, int32 m, int32 n, int32 data);
extern int32 dsk2 (int32 op, int32 m, int32 n, int32 data);
extern int32 cpu (int32 op, int32 m, int32 n, int32 data);
int32 nulldev (int32 opcode, int32 m, int32 n, int32 data);
int32 add_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2);
int32 subtract_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2);
static int32 compare(int32 byte1, int32 byte2, int32 cond);
static int32 condition(int32 qbyte);
static void store_decimal (int32 addr, int32 len, uint8 *dec, int sign);
static void load_decimal (int32 addr, int32 len, uint8 *result, int *count, int *sign);
static void add_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count);
static void subtract_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count, int *sign);
int32 GetMem(int32 addr);
int32 PutMem(int32 addr, int32 data);
/* IOT dispatch table */
/* System/3 supports only 16 unique device addresses! */
struct ndev dev_table[16] = {
{ 0, 0, &cpu }, /* Device 0: CPU control */
{ 1, 0, &pkb }, /* Device 1: 5471 console printer/keyboard */
{ 0, 0, &nulldev },
{ 0, 0, &nulldev },
{ 0, 0, &nulldev },
{ 0, 0, &crd }, /* Device 5: 1442 card reader/punch */
{ 0, 0, &nulldev }, /* Device 6: 3410 Tape drives 1 & 2 */
{ 0, 0, &nulldev }, /* Device 7: 3410 Tape drives 3 & 4 */
{ 0, 0, &nulldev },
{ 0, 0, &nulldev },
{ 0, 0, &dsk1 }, /* Device 10: 5444 Disk Drive 1 */
{ 0, 0, &dsk2 }, /* Device 11: 5444 Disk Drive 2 */
{ 0, 0, &nulldev }, /* Device 12: 5448 Disk Drive 1 */
{ 0, 0, &nulldev }, /* DEvice 13: 5448 Disk Drive 2 */
{ 0, 0, &lpt }, /* Device 14: 1403/5203 Printer */
{ 0, 0, &nulldev } /* Device 15: 5424 MFCU */
};
/* Priority assigned to interrupt levels */
int32 priority[8] = {8, 7, 5, 4, 3, 6, 2, 1};
/* CPU data structures
cpu_dev CPU device descriptor
cpu_unit CPU unit descriptor
cpu_reg CPU register list
cpu_mod CPU modifiers list
*/
UNIT cpu_unit = { UDATA (NULL, UNIT_FIX + UNIT_BINK, MAXMEMSIZE) };
REG cpu_reg[] = {
{ HRDATA (IAR, saved_PC, 16), REG_RO },
{ HRDATA (IAR-P1, IAR[8], 16) },
{ HRDATA (IAR-P2, IAR[9], 16) },
{ HRDATA (ARR-P1, ARR[8], 16) },
{ HRDATA (ARR-P2, ARR[9], 16) },
{ HRDATA (AAR, AAR, 16) },
{ HRDATA (BAR, BAR, 16) },
{ HRDATA (XR1, XR1, 16) },
{ HRDATA (XR2, XR2, 16) },
{ HRDATA (PSR, PSR, 16) },
{ HRDATA (SR, SR, 16) },
{ HRDATA (INT, int_req, 16), REG_RO },
{ HRDATA (LEVEL, level, 16) },
{ HRDATA (IAR0, IAR[0], 16) },
{ HRDATA (IAR1, IAR[1], 16) },
{ HRDATA (IAR2, IAR[2], 16) },
{ HRDATA (IAR3, IAR[3], 16) },
{ HRDATA (IAR4, IAR[4], 16) },
{ HRDATA (IAR5, IAR[5], 16) },
{ HRDATA (IAR6, IAR[6], 16) },
{ HRDATA (IAR7, IAR[7], 16) },
{ HRDATA (ARR0, ARR[0], 16) },
{ HRDATA (ARR1, ARR[1], 16) },
{ HRDATA (ARR2, ARR[2], 16) },
{ HRDATA (ARR3, ARR[3], 16) },
{ HRDATA (ARR4, ARR[4], 16) },
{ HRDATA (ARR5, ARR[5], 16) },
{ HRDATA (ARR6, ARR[6], 16) },
{ HRDATA (ARR7, ARR[7], 16) },
{ HRDATA (DISABLE, dev_disable, 16), REG_RO },
{ FLDATA (STOP_DEV, stop_dev, 0) },
{ HRDATA (WRU, sim_int_char, 8) },
{ HRDATA (DEBUG, debug_reg, 16) },
{ NULL }
};
MTAB cpu_mod[] = {
{ UNIT_M15, UNIT_M15, "M15", "M15", NULL },
{ UNIT_M15, 0, "M10", "M10", NULL },
{ UNIT_DPF, UNIT_DPF, "DPF", "DPF", NULL },
{ UNIT_DPF, 0, "NODPF", "NODPF", NULL },
{ UNIT_MSIZE, 8192, NULL, "8K", &cpu_set_size },
{ UNIT_MSIZE, 16384, NULL, "16K", &cpu_set_size },
{ UNIT_MSIZE, 32768, NULL, "32K", &cpu_set_size },
{ UNIT_MSIZE, 49152, NULL, "48K", &cpu_set_size },
{ UNIT_MSIZE, 65535, NULL, "64K", &cpu_set_size },
{ 0 }
};
DEVICE cpu_dev = {
"CPU", &cpu_unit, cpu_reg, cpu_mod,
1, 16, 16, 1, 16, 8,
&cpu_ex, &cpu_dep, &cpu_reset,
NULL, NULL, NULL
};
t_stat sim_instr (void)
{
register int32 PC, IR;
int32 i, j, carry, zero, op1, op2;
int32 opcode = 0, qbyte = 0, rbyte = 0;
int32 opaddr, addr1, addr2, dlen1, dlen2, r;
int32 int_savelevel = 8, intpri, intlev, intdev, intmask;
int32 devno, devm, devn;
char display[3][9];
int32 val [32];
register t_stat reason;
/* Restore register state */
PC = IAR[level]; /* load local PC */
reason = 0;
/* Main instruction fetch/decode loop */
while (reason == 0) { /* loop until halted */
if (sim_interval <= 0) { /* check clock queue */
if ((reason = sim_process_event ())) break;
}
if (int_req) { /* interrupt? */
intpri = 16;
for (i = 0; i < 16; i++) { /* Get highest priority device */
if ((int_req >> i) & 0x01) {
intlev = dev_table[i].level;
if (priority[intlev] < intpri) {
intdev = i;
intpri = priority[intlev];
}
}
}
intmask = 1 << intdev; /* mask is interrupting dev bit */
int_req = ~int_req & intmask; /* Turn off int_req for device */
int_savelevel = level; /* save current level for reset */
level = dev_table[intdev].level; /* get int level from device */
PC = IAR[level]; /* Use int level IAR for new PC */
} /* end interrupt */
if (sim_brk_summ && sim_brk_test (PC, SWMASK ('E'))) { /* breakpoint? */
reason = STOP_IBKPT; /* stop simulation */
break;
}
/* Machine Instruction Execution Here */
if ((debug_reg == 0) && debug_flag == 1) {
fclose(trace);
debug_flag = 0;
}
if (debug_reg) {
if (!debug_flag) {
trace = fopen("trace.log", "w");
debug_flag = 1;
}
}
if (debug_reg & 0x01) {
fprintf(trace, "ARR=%04X XR1=%04X XR2=%04X IAR=%04X ", ARR[level], XR1, XR2, PC);
val[0] = GetMem(PC);
val[1] = GetMem(PC+1);
val[2] = GetMem(PC+2);
val[3] = GetMem(PC+3);
val[4] = GetMem(PC+4);
val[5] = GetMem(PC+5);
fprint_sym(trace, PC, (uint32 *) val, &cpu_unit, SWMASK('M'));
fprintf(trace, "\n");
}
saved_PC = PC;
opaddr = GetMem(PC) & 0xf0; /* fetch addressing mode */
opcode = GetMem(PC) & 0x0f; /* fetch opcode */
PC = (PC + 1) & AMASK;
sim_interval = sim_interval - 1;
qbyte = GetMem(PC) & 0xff; /* fetch qbyte */
PC = (PC + 1) & AMASK;
if (opaddr == 0xf0) { /* Is it command format? */
rbyte = GetMem(PC) & 0xff;
PC = (PC + 1) & AMASK;
switch (opcode) {
case 0x00: /* HPL: Halt Program Level */
for (i = 0; i < 3; i++) {
for (j = 0; j < 9; j++) {
display[i][j] = ' ';
}
}
/* First line */
if (qbyte & 0x04) display[0][2] = '_' ;
if (rbyte & 0x04) display[0][6] = '_' ;
/* Second line */
if (qbyte & 0x08) display[1][1] = '|' ;
if (rbyte & 0x08) display[1][5] = '|' ;
if (qbyte & 0x10) display[1][2] = '_' ;
if (rbyte & 0x10) display[1][6] = '_' ;
if (qbyte & 0x02) display[1][3] = '|' ;
if (rbyte & 0x02) display[1][7] = '|' ;
/* Third line */
if (qbyte & 0x20) display[2][1] = '|' ;
if (rbyte & 0x20) display[2][5] = '|' ;
if (qbyte & 0x40) display[2][2] = '_' ;
if (rbyte & 0x40) display[2][6] = '_' ;
if (qbyte & 0x01) display[2][3] = '|' ;
if (rbyte & 0x01) display[2][7] = '|' ;
/* Print display segment array */
sim_printf("\n");
for (i = 0; i < 3; i++) {
for (j = 0; j < 9; j++) {
sim_printf ("%c", display[i][j]);
}
sim_printf ("\n");
}
reason = STOP_HALT;
break;
case 0x01: /* APL: Advance Program Level */
devno = (qbyte >> 4) & 0x0f;
devm = (qbyte >> 3) & 0x01;
devn = qbyte & 0x07;
op1 = dev_table[devno].routine(4, devm, devn, rbyte);
if (op1 & 0x01) {
if (cpu_unit.flags & UNIT_DPF) { /* Dual Programming? */
if (level == 8) /* Yes: switch program levels */
level = 9;
else
level = 8;
PC = IAR[level];
} else { /* No: Loop on this inst */
PC = PC - 3;
}
}
reason = (op1 >> 16) & 0xffff;
break;
case 0x02: /* JC: Jump on Condition */
if (condition(qbyte) == 1) {
PC = (PC + rbyte) & AMASK;
}
break;
case 0x03: /* SIO: Start I/O */
devno = (qbyte >> 4) & 0x0f;
devm = (qbyte >> 3) & 0x01;
devn = qbyte & 0x07;
reason = dev_table[devno].routine(0, devm, devn, rbyte);
if (reason == RESET_INTERRUPT) {
reason = SCPE_OK;
IAR[level] = PC;
level = int_savelevel;
PC = IAR[level];
}
break;
default:
reason = STOP_INVOP;
break;
} /* switch (opcode) */
IAR[level] = PC;
continue;
}
/* Not command format: fetch the addresses */
addr1 = (opaddr >> 6) & 3;
addr2 = (opaddr >> 4) & 3;
switch (addr1) {
case 0:
BAR = GetMem(PC) << 8;
PC = (PC + 1) & AMASK;
BAR |=GetMem(PC);
PC = (PC + 1) & AMASK;
break;
case 1:
BAR = GetMem(PC);
BAR = (BAR + XR1) & AMASK;
PC = (PC + 1) & AMASK;
break;
case 2:
BAR = GetMem(PC);
BAR = (BAR + XR2) & AMASK;
PC = (PC + 1) & AMASK;
break;
case 3:
break;
default:
break;
} /* switch (addr1) */
switch (addr2) {
case 0:
AAR = GetMem(PC) << 8;
PC = (PC + 1) & AMASK;
AAR |= GetMem(PC);
PC = (PC + 1) & AMASK;
break;
case 1:
AAR = GetMem(PC);
AAR = (AAR + XR1) & AMASK;
PC = (PC + 1) & AMASK;
break;
case 2:
AAR = GetMem(PC);
AAR = (AAR + XR2) & AMASK;
PC = (PC + 1) & AMASK;
break;
case 3:
break;
default:
break;
} /* switch (addr1) */
switch (opaddr) {
case 0x00:
case 0x10:
case 0x20:
case 0x40:
case 0x50:
case 0x60:
case 0x80:
case 0x90:
case 0xa0:
switch (opcode) {
case 4: /* ZAZ: Zero and Add Zoned */
dlen2 = qbyte & 0x0f;
dlen1 = (qbyte >> 4) & 0xf;
dlen1 += dlen2;
op1 = BAR;
for (i = 0; i < (dlen1+1); i++) {
PutMem(op1, 0xf0);
op1--;
}
r = add_zoned(BAR, dlen1+1, AAR, dlen2+1);
PSR &= 0xF8; /* HJS mod */
switch (r) {
case 0:
PSR |= 0x01;
break;
case 1:
PSR |= 0x02;
break;
case 2:
PSR |= 0x04;
break;
default:
break;
}
break;
case 6: /* AZ: Add Zoned */
dlen2 = qbyte & 0x0f;
dlen1 = (qbyte >> 4) & 0xf;
dlen1 += dlen2;
r = add_zoned(BAR, dlen1+1, AAR, dlen2+1);
PSR &= 0xF0;
switch (r) {
case 0:
PSR |= 0x01;
break;
case 1:
PSR |= 0x02;
break;
case 2:
PSR |= 0x04;
break;
case 3:
PSR |= 0x08;
break;
default:
break;
}
break;
case 7: /* SZ: Subtract Zoned */
dlen2 = qbyte & 0x0f;
dlen1 = (qbyte >> 4) & 0xf;
dlen1 += dlen2;
r = subtract_zoned(BAR, dlen1+1, AAR, dlen2+1);
PSR &= 0xF0;
switch (r) {
case 0:
PSR |= 0x01;
break;
case 1:
PSR |= 0x02;
break;
case 2:
PSR |= 0x04;
break;
case 3:
PSR |= 0x08;
break;
default:
break;
}
break;
case 8: /* MVX: Move Hex */
op1 = GetMem(BAR);
op2 = GetMem(AAR);
switch (qbyte) {
case 0: /* Zone to zone */
op1 = (op1 & 0x0F) | (op2 & 0xF0);
break;
case 1: /* Numeric to zone */
op1 = (op1 & 0x0F) | (op2 << 4);
break;
case 2: /* Zone to numeric */
op1 = (op1 & 0xF0) | (op2 >> 4);
break;
case 3: /* Numeric to numeric */
op1 = (op1 & 0xF0) | (op2 & 0x0F);
break;
default:
reason = STOP_INVQ;
break;
}
PutMem(BAR, op1);
break;
case 0xa: /* ED: Edit */
zero = 1;
PSR &= 0xF8;
IR = GetMem(AAR);
if ((IR & 0xf0) != 0xF0)
PSR |= 0x02;
else
PSR |= 0x04;
while (qbyte > -1) {
op2 = GetMem(AAR);
op1 = GetMem(BAR);
if (op1 == 0x20) {
op2 |= 0xf0;
PutMem(BAR, op2);
AAR--;
if (op2 != 0xF0) zero = 0;
}
BAR--;
qbyte--;
}
if (zero)
PSR |= 0x01;
break;
case 0xb: /* ITC: Insert and Test Chars */
op2 = GetMem(AAR);
while (qbyte > -1) {
op1 = GetMem(BAR);
if (op1 >= 0xF1 && op1 <= 0xF9)
break;
PutMem(BAR, op2);
BAR++;
qbyte--;
}
ARR[level] = BAR;
break;
case 0xc: /* MVC: Move Characters */
while (qbyte > -1) {
PutMem(BAR, GetMem(AAR));
BAR--;
AAR--;
qbyte--;
}
break;
case 0xd: /* CLC: Compare Characters */
PSR &= 0xF8;
i = BAR = BAR - qbyte;
j = AAR = AAR - qbyte;
while (qbyte > -1) {
if (GetMem(i) > GetMem(j)) {
PSR |= 0x04;
break;
}
if (GetMem(i) < GetMem(j)) {
PSR |= 0x02;
break;
}
i++;
j++;
qbyte--;
}
if (qbyte == -1)
PSR |= 0x01;
break;
case 0xe: /* ALC: Add Logical Characters */
carry = 0;
zero = 1;
while (qbyte > -1) {
IR = GetMem(BAR) + GetMem(AAR) + carry;
if (IR & 0x100)
carry = 1;
else
carry = 0;
if ((IR & 0xFF) != 0) zero = 0; /* HJS mod */
PutMem(BAR,(IR & 0xFF));
BAR--;
AAR--;
qbyte--;
}
PSR &= 0xD8;
if (zero)
PSR |= 0x01; /* Equal */
if (!zero && !carry)
PSR |= 0x02; /* Low */
if (!zero && carry)
PSR |= 0x04; /* High */
if (carry)
PSR |= 0x20; /* Overflow */
break;
case 0xf: /* SLC: Subtract Logical Characters */
carry = 1;
zero = 1;
while (qbyte > -1) {
IR = GetMem(BAR) + (0xFF - GetMem(AAR)) + carry;
if (IR & 0x100)
carry = 1;
else
carry = 0;
if ((IR & 0xFF) != 0) zero = 0; /* HJS mod */
PutMem(BAR,(IR & 0xFF));
BAR--;
AAR--;
qbyte--;
}
PSR &= 0xF8;
if (zero)
PSR |= 0x01; /* Equal */
if (!zero && !carry)
PSR |= 0x02; /* Low */
if (!zero && carry)
PSR |= 0x04; /* High */
break;
default:
reason = STOP_INVOP;
break;
}
IAR[level] = PC;
continue;
break;
case 0x30:
case 0x70:
case 0xb0:
switch (opcode) {
case 0: /* SNS: Sense I/O */
devno = (qbyte >> 4) & 0x0f;
devm = (qbyte >> 3) & 0x01;
devn = qbyte & 0x07;
i = dev_table[devno].routine(3, devm, devn, rbyte);
PutMem(BAR, i & 0xff);
BAR--;
PutMem(BAR, (i >> 8) & 0xff);
reason = (i >> 16) & 0xffff;
break;
case 1: /* LIO: Load I/O */
devno = (qbyte >> 4) & 0x0f;
devm = (qbyte >> 3) & 0x01;
devn = qbyte & 0x07;
op1 = GetMem(BAR);
BAR--;
op1 |= (GetMem(BAR) << 8) & 0xff00;
reason = dev_table[devno].routine(1, devm, devn, op1);
break;
case 4: /* ST: Store Register */
switch (qbyte) {
case 0x01:
PutMem(BAR, XR1 & 0xff);
BAR--;
PutMem(BAR, (XR1 >> 8) & 0xff);
break;
case 0x02:
PutMem(BAR, XR2 & 0xff);
BAR--;
PutMem(BAR, (XR2 >> 8) & 0xff);
break;
case 0x04:
PutMem(BAR, PSR & 0xFF);
BAR--;
PutMem(BAR, 0); /* LCRR, not imp. */
break;
case 0x08:
PutMem(BAR, ARR[level] & 0xff);
BAR--;
PutMem(BAR, (ARR[level] >> 8) & 0xff);
break;
case 0x10:
PutMem(BAR, IAR[level] & 0xff);
BAR--;
PutMem(BAR, (IAR[level] >> 8) & 0xff);
break;
case 0x20:
PutMem(BAR, IAR[8] & 0xff);
BAR--;
PutMem(BAR, (IAR[8] >> 8) & 0xff);
break;
case 0x40:
PutMem(BAR, IAR[9] & 0xff);
BAR--;
PutMem(BAR, (IAR[9] >> 8) & 0xff);
break;
case 0x80:
PutMem(BAR, IAR[0] & 0xff);
BAR--;
PutMem(BAR, (IAR[0] >> 8) & 0xff);
break;
case 0x81:
PutMem(BAR, IAR[7] & 0xff);
BAR--;
PutMem(BAR, (IAR[7] >> 8) & 0xff);
break;
case 0x82:
PutMem(BAR, IAR[6] & 0xff);
BAR--;
PutMem(BAR, (IAR[6] >> 8) & 0xff);
break;
case 0x84:
PutMem(BAR, IAR[5] & 0xff);
BAR--;
PutMem(BAR, (IAR[5] >> 8) & 0xff);
break;
case 0x88:
PutMem(BAR, IAR[4] & 0xff);
BAR--;
PutMem(BAR, (IAR[4] >> 8) & 0xff);
break;
case 0x90:
PutMem(BAR, IAR[3] & 0xff);
BAR--;
PutMem(BAR, (IAR[3] >> 8) & 0xff);
break;
case 0xA0:
PutMem(BAR, IAR[2] & 0xff);
BAR--;
PutMem(BAR, (IAR[2] >> 8) & 0xff);
break;
case 0xC0:
PutMem(BAR, IAR[1] & 0xff);
BAR--;
PutMem(BAR, (IAR[1] >> 8) & 0xff);
break;
default:
reason = STOP_INVQ;
break;
}
break;
case 5: /* L: Load Register */
switch (qbyte) {
case 0x01:
XR1 = GetMem(BAR) & 0xff;
BAR--;
XR1 |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x02:
XR2 = GetMem(BAR) & 0xff;
BAR--;
XR2 |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x04:
PSR = GetMem(BAR) & 0xff;
BAR--;
break;
case 0x08:
ARR[level] = GetMem(BAR) & 0xff;
BAR--;
ARR[level] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x10:
IAR[level] = GetMem(BAR) & 0xff;
BAR--;
IAR[level] |= (GetMem(BAR) << 8) & 0xff00;
PC = IAR[level];
break;
case 0x20:
IAR[8] = GetMem(BAR) & 0xff;
BAR--;
IAR[8] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x40:
IAR[9] = GetMem(BAR) & 0xff;
BAR--;
IAR[9] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x80:
IAR[0] = GetMem(BAR) & 0xff;
BAR--;
IAR[0] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x81:
IAR[7] = GetMem(BAR) & 0xff;
BAR--;
IAR[7] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x82:
IAR[6] = GetMem(BAR) & 0xff;
BAR--;
IAR[6] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x84:
IAR[5] = GetMem(BAR) & 0xff;
BAR--;
IAR[5] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x88:
IAR[4] = GetMem(BAR) & 0xff;
BAR--;
IAR[4] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0x90:
IAR[3] = GetMem(BAR) & 0xff;
BAR--;
IAR[3] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0xA0:
IAR[2] = GetMem(BAR) & 0xff;
BAR--;
IAR[2] |= (GetMem(BAR) << 8) & 0xff00;
break;
case 0xC0:
IAR[1] = GetMem(BAR) & 0xff;
BAR--;
IAR[1] |= (GetMem(BAR) << 8) & 0xff00;
break;
default:
reason = STOP_INVQ;
break;
}
break;
case 6: /* A: Add to Register */
IR = GetMem(BAR) & 0x00ff;
BAR--;
IR |= (GetMem(BAR) << 8) & 0xff00;
switch (qbyte) {
case 0x01:
IR += XR1;
XR1 = IR & AMASK;
break;
case 0x02:
IR += XR2;
XR2 = IR & AMASK;
break;
case 0x04:
IR += PSR;
PSR = IR & AMASK;
break;
case 0x08:
IR += ARR[level];
ARR[level] = IR & AMASK;
break;
case 0x10:
IR += IAR[level];
IAR[level] = IR & AMASK;
break;
case 0x20:
IR += IAR[8];
IAR[8] = IR & AMASK;
break;
case 0x40:
IR += IAR[9];
IAR[9] = IR & AMASK;
break;
case 0x80:
IR += IAR[0];
IAR[0] = IR & AMASK;
break;
case 0x81:
IR += IAR[7];
IAR[7] = IR & AMASK;
break;
case 0x82:
IR += IAR[6];
IAR[6] = IR & AMASK;
break;
case 0x84:
IR += IAR[5];
IAR[5] = IR & AMASK;
break;
case 0x88:
IR += IAR[4];
IAR[4] = IR & AMASK;
break;
case 0x90:
IR += IAR[3];
IAR[3] = IR & AMASK;
break;
case 0xA0:
IR += IAR[2];
IAR[2] = IR & AMASK;
break;
case 0xC0:
IR += IAR[1];
IAR[1] = IR & AMASK;
break;
default:
reason = STOP_INVQ;
break;
}
PSR &= 0xD8;
if ((IR & 0xffff) == 0)
PSR |= 0x01; /* Zero */
if ((IR & 0xffff) != 0 && !(IR & 0x10000))
PSR |= 0x02; /* Low */
if ((IR & 0xffff) != 0 && (IR & 0x10000))
PSR |= 0x04; /* High */
if ((IR & 0x10000))
PSR |= 0x20; /* Bin overflow */
break;
case 8: /* TBN: Test Bits On */
IR = GetMem(BAR);
PSR &= 0xFF;
if ((IR & qbyte) != qbyte)
PSR |= 0x10;
break;
case 9: /* TBF: Test Bits Off */
IR = GetMem(BAR);
PSR &= 0xFF;
if ((IR & qbyte))
PSR |= 0x10;
break;
case 0xa: /* SBN: Set Bits On */
IR = GetMem(BAR);
IR |= qbyte;
PutMem(BAR, IR);
break;
case 0xb: /* SBF: Set Bits Off */
IR = GetMem(BAR);
IR &= ~qbyte;
PutMem(BAR, IR);
break;
case 0xc: /* MVI: Move Immediate */
PutMem(BAR, qbyte);
break;
case 0xd: /* CLI: Compare Immediate */
PSR = compare(GetMem(BAR), qbyte, PSR);
break;
default:
reason = STOP_INVOP;
break;
}
IAR[level] = PC;
continue;
break;
case 0xc0:
case 0xd0:
case 0xe0:
switch (opcode) {
case 0: /* BC: Branch on Condition */
ARR[level] = AAR & AMASK;
if (condition(qbyte) == 1) {
IR = ARR[level];
ARR[level] = PC & AMASK;
PC = IR;
}
break;
case 1: /* TIO: Test I/O */
devno = (qbyte >> 4) & 0x0f;
devm = (qbyte >> 3) & 0x01;
devn = qbyte & 0x07;
op1 = dev_table[devno].routine(2, devm, devn, rbyte);
if (op1 & 0x01) {
ARR[level] = AAR & AMASK;
IR = ARR[level];
ARR[level] = PC & AMASK;
PC = IR;
}
reason = (op1 >> 16) & 0xffff;
break;
case 2: /* LA: Load Address */
switch (qbyte) {
case 1:
XR1 = AAR;
break;
case 2:
XR2 = AAR;
break;
default:
reason = STOP_INVQ;
break;
}
break;
default:
reason = STOP_INVOP;
break;
} /* switch (opcode) */
IAR[level] = PC;
continue;
default:
reason = STOP_INVOP;
break;
} /* switch (opaddr) */
} /* end while (reason == 0) */
/* Simulation halted */
saved_PC = PC;
return reason;
}
/* On models 4-12, these memory functions could be inline, but
on a model 15 with ATU address mapping must be performed so
they are in functions here for future expansion.
*/
/* Fetch a byte from memory */
int32 GetMem(int32 addr)
{
return M[addr] & 0xff;
}
/* Place a byte in memory */
int32 PutMem(int32 addr, int32 data)
{
M[addr] = data & 0xff;
return 0;
}
/* Check the condition register against the qbyte and return 1 if true */
static int32 condition(int32 qbyte)
{
int32 r = 0, t, q;
t = (qbyte & 0xf0) >> 4;
q = qbyte & 0x0f;
if (qbyte & 0x80) { /* True if any condition tested = 1*/
if (((qbyte & 0x3f) & PSR) != 0) r = 1;
} else { /* True if all conditions tested = 0 */
if (((qbyte & 0x3f) & PSR) == 0) r = 1;
}
/* these bits reset by a test */
if (qbyte & 0x10)
PSR &= 0xEF; /* Reset test false if used */
if (qbyte & 0x08)
PSR &= 0xF7; /* Reset decimal overflow if tested */
if (qbyte == 0x00)
r = 1; /* unconditional branch */
if (qbyte == 0x80)
r = 0; /* force no branch */
if (t >=0 && t < 8 && (q == 7 || q == 0xf))
r = 0; /* no-op */
if (t > 7 && t < 0x10 && (q == 7 || q == 0xf))
r = 1; /* Force branch */
return (r);
}
/* Given operand 1 and operand 2, compares the two and returns
the System/3 condition register bits appropriately, given the
condition register initial state in parameter 3
*/
static int32 compare(int32 byte1, int32 byte2, int32 cond)
{
int32 r;
r = cond & 0xF8; /* mask off all but unaffected bits 2,3,4 */
if (byte1 == byte2)
r |= 0x01; /* set equal bit */
if (byte1 < byte2)
r |= 0x02; /* set less-than bit */
if (byte1 > byte2)
r |= 0x04; /* set greater than bit */
return r;
}
/*-------------------------------------------------------------------*/
/* Add two zoned decimal operands */
/* */
/* Input: */
/* addr1 Logical address of packed decimal storage operand 1 */
/* len1 Length minus one of storage operand 1 (range 0-15) */
/* addr2 Logical address of packed decimal storage operand 2 */
/* len2 Length minus one of storage operand 2 (range 0-15) */
/* Output: */
/* The return value is the condition code: */
/* 0=result zero, 1=result -ve, 2=result +ve, 3=overflow */
/* */
/* A program check may be generated if either logical address */
/* causes an addressing, translation, or fetch protection */
/* exception, or if either operand causes a data exception */
/* because of invalid decimal digits or sign, or if the */
/* first operand is store protected. Depending on the PSW */
/* program mask, decimal overflow may cause a program check. */
/*-------------------------------------------------------------------*/
int32 add_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2)
{
int cc; /* Condition code */
uint8 dec1[MAX_DECIMAL_DIGITS]; /* Work area for operand 1 */
uint8 dec2[MAX_DECIMAL_DIGITS]; /* Work area for operand 2 */
uint8 dec3[MAX_DECIMAL_DIGITS]; /* Work area for result */
int count1, count2, count3; /* Significant digit counters*/
int sign1, sign2, sign3; /* Sign of operands & result */
/* Load operands into work areas */
load_decimal (addr1, len1, dec1, &count1, &sign1);
load_decimal (addr2, len2, dec2, &count2, &sign2);
/* Add or subtract operand values */
if (count2 == 0)
{
/* If second operand is zero then result is first operand */
memcpy (dec3, dec1, MAX_DECIMAL_DIGITS);
count3 = count1;
sign3 = sign1;
}
else if (count1 == 0)
{
/* If first operand is zero then result is second operand */
memcpy (dec3, dec2, MAX_DECIMAL_DIGITS);
count3 = count2;
sign3 = sign2;
}
else if (sign1 == sign2)
{
/* If signs are equal then add operands */
add_decimal (dec1, dec2, dec3, &count3);
sign3 = sign1;
}
else
{
/* If signs are opposite then subtract operands */
subtract_decimal (dec1, dec2, dec3, &count3, &sign3);
if (sign1 < 0) sign3 = -sign3;
}
/* Set condition code */
cc = (count3 == 0) ? 0 : (sign3 < 1) ? 1 : 2;
/* Overflow if result exceeds first operand length */
if (count3 > len1)
cc = 3;
/* Set positive sign if result is zero */
if (count3 == 0)
sign3 = 1;
/* Store result into first operand location */
store_decimal (addr1, len1, dec3, sign3);
/* Return condition code */
return cc;
} /* end function add_packed */
/*-------------------------------------------------------------------*/
/* Subtract two zoned decimal operands */
/* */
/* Input: */
/* addr1 Logical address of packed decimal storage operand 1 */
/* len1 Length minus one of storage operand 1 (range 0-15) */
/* addr2 Logical address of packed decimal storage operand 2 */
/* len2 Length minus one of storage operand 2 (range 0-15) */
/* Output: */
/* The return value is the condition code: */
/* 0=result zero, 1=result -ve, 2=result +ve, 3=overflow */
/* */
/* A program check may be generated if either logical address */
/* causes an addressing, translation, or fetch protection */
/* exception, or if either operand causes a data exception */
/* because of invalid decimal digits or sign, or if the */
/* first operand is store protected. Depending on the PSW */
/* program mask, decimal overflow may cause a program check. */
/*-------------------------------------------------------------------*/
int32 subtract_zoned (int32 addr1, int32 len1, int32 addr2, int32 len2)
{
int cc; /* Condition code */
uint8 dec1[MAX_DECIMAL_DIGITS]; /* Work area for operand 1 */
uint8 dec2[MAX_DECIMAL_DIGITS]; /* Work area for operand 2 */
uint8 dec3[MAX_DECIMAL_DIGITS]; /* Work area for result */
int count1, count2, count3; /* Significant digit counters*/
int sign1, sign2, sign3; /* Sign of operands & result */
/* Load operands into work areas */
load_decimal (addr1, len1, dec1, &count1, &sign1);
load_decimal (addr2, len2, dec2, &count2, &sign2);
/* Add or subtract operand values */
if (count2 == 0)
{
/* If second operand is zero then result is first operand */
memcpy (dec3, dec1, MAX_DECIMAL_DIGITS);
count3 = count1;
sign3 = sign1;
}
else if (count1 == 0)
{
/* If first operand is zero then result is -second operand */
memcpy (dec3, dec2, MAX_DECIMAL_DIGITS);
count3 = count2;
sign3 = -sign2;
}
else if (sign1 != sign2)
{
/* If signs are opposite then add operands */
add_decimal (dec1, dec2, dec3, &count3);
sign3 = sign1;
}
else
{
/* If signs are equal then subtract operands */
subtract_decimal (dec1, dec2, dec3, &count3, &sign3);
if (sign1 < 0) sign3 = -sign3;
}
/* Set condition code */
cc = (count3 == 0) ? 0 : (sign3 < 1) ? 1 : 2;
/* Overflow if result exceeds first operand length */
if (count3 > len1)
cc = 3;
/* Set positive sign if result is zero */
if (count3 == 0)
sign3 = 1;
/* Store result into first operand location */
store_decimal (addr1, len1, dec3, sign3);
/* Return condition code */
return cc;
} /* end function subtract_packed */
/*-------------------------------------------------------------------*/
/* Add two decimal byte strings as unsigned decimal numbers */
/* */
/* Input: */
/* dec1 A 31-byte area containing the decimal digits of */
/* the first operand. Each byte contains one decimal */
/* digit in the low-order 4 bits of the byte. */
/* dec2 A 31-byte area containing the decimal digits of */
/* the second operand. Each byte contains one decimal */
/* digit in the low-order 4 bits of the byte. */
/* Output: */
/* result Points to a 31-byte area to contain the result */
/* digits. One decimal digit is placed in the low-order */
/* 4 bits of each byte. */
/* count Points to an integer to receive the number of */
/* digits in the result excluding leading zeroes. */
/* This field is set to zero if the result is all zero, */
/* or to MAX_DECIMAL_DIGITS+1 if overflow occurred. */
/*-------------------------------------------------------------------*/
static void add_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count)
{
int d; /* Decimal digit */
int i; /* Array subscript */
int n = 0; /* Significant digit counter */
int carry = 0; /* Carry indicator */
/* Add digits from right to left */
for (i = MAX_DECIMAL_DIGITS - 1; i >= 0; i--)
{
/* Add digits from first and second operands */
d = dec1[i] + dec2[i] + carry;
/* Check for carry into next digit */
if (d > 9) {
d -= 10;
carry = 1;
} else {
carry = 0;
}
/* Check for significant digit */
if (d != 0)
n = MAX_DECIMAL_DIGITS - i;
/* Store digit in result */
result[i] = d;
} /* end for */
/* Check for carry out of leftmost digit */
if (carry)
n = MAX_DECIMAL_DIGITS + 1;
/* Return significant digit counter */
*count = n;
} /* end function add_decimal */
/*-------------------------------------------------------------------*/
/* Subtract two decimal byte strings as unsigned decimal numbers */
/* */
/* Input: */
/* dec1 A 31-byte area containing the decimal digits of */
/* the first operand. Each byte contains one decimal */
/* digit in the low-order 4 bits of the byte. */
/* dec2 A 31-byte area containing the decimal digits of */
/* the second operand. Each byte contains one decimal */
/* digit in the low-order 4 bits of the byte. */
/* Output: */
/* result Points to a 31-byte area to contain the result */
/* digits. One decimal digit is placed in the low-order */
/* 4 bits of each byte. */
/* count Points to an integer to receive the number of */
/* digits in the result excluding leading zeroes. */
/* This field is set to zero if the result is all zero. */
/* sign -1 if the result is negative (operand2 > operand1) */
/* +1 if the result is positive (operand2 <= operand1) */
/*-------------------------------------------------------------------*/
static void subtract_decimal (uint8 *dec1, uint8 *dec2, uint8 *result, int *count, int *sign)
{
int d; /* Decimal digit */
int i; /* Array subscript */
int n = 0; /* Significant digit counter */
int borrow = 0; /* Borrow indicator */
int rc; /* Return code */
uint8 *higher; /* -> Higher value operand */
uint8 *lower; /* -> Lower value operand */
/* Compare digits to find which operand has higher numeric value */
rc = memcmp (dec1, dec2, MAX_DECIMAL_DIGITS);
/* Return positive zero result if both operands are equal */
if (rc == 0) {
memset (result, 0, MAX_DECIMAL_DIGITS);
*count = 0;
*sign = +1;
return;
}
/* Point to higher and lower value operands and set sign */
if (rc > 0) {
higher = dec1;
lower = dec2;
*sign = +1;
} else {
lower = dec1;
higher = dec2;
*sign = -1;
}
/* Subtract digits from right to left */
for (i = MAX_DECIMAL_DIGITS - 1; i >= 0; i--)
{
/* Subtract lower operand digit from higher operand digit */
d = higher[i] - lower[i] - borrow;
/* Check for borrow from next digit */
if (d < 0) {
d += 10;
borrow = 1;
} else {
borrow = 0;
}
/* Check for significant digit */
if (d != 0)
n = MAX_DECIMAL_DIGITS - i;
/* Store digit in result */
result[i] = d;
} /* end for */
/* Return significant digit counter */
*count = n;
} /* end function subtract_decimal */
/*-------------------------------------------------------------------*/
/* Load a zoned decimal storage operand into a decimal byte string */
/* */
/* Input: */
/* addr Logical address of zoned decimal storage operand */
/* len Length minus one of storage operand (range 0-15) */
/* Output: */
/* result Points to a 31-byte area into which the decimal */
/* digits are loaded. One decimal digit is loaded */
/* into the low-order 4 bits of each byte, and the */
/* result is padded to the left with high-order zeroes */
/* if the storage operand contains less than 31 digits. */
/* count Points to an integer to receive the number of */
/* digits in the result excluding leading zeroes. */
/* This field is set to zero if the result is all zero. */
/* sign Points to an integer which will be set to -1 if a */
/* negative sign was loaded from the operand, or +1 if */
/* a positive sign was loaded from the operand. */
/* */
/* A program check may be generated if the logical address */
/* causes an addressing, translation, or fetch protection */
/* exception, or if the operand causes a data exception */
/* because of invalid decimal digits or sign. */
/*-------------------------------------------------------------------*/
static void load_decimal (int32 addr, int32 len, uint8 *result, int *count, int *sign)
{
int h; /* Hexadecimal digit */
int i, j; /* Array subscripts */
int n; /* Significant digit counter */
if ((GetMem(addr) & 0xf0) == 0xD0)
*sign = -1;
else
*sign = 1;
j = len;
for (i = MAX_DECIMAL_DIGITS; i > -1; i--) {
if (j) {
h = GetMem(addr) & 0x0f;
addr--;
j--;
} else {
h = 0;
}
result [i-1] = h;
if (h > 0) n = i;
}
*count = 32 - n;
} /* end function load_decimal */
/*-------------------------------------------------------------------*/
/* Store decimal byte string into packed decimal storage operand */
/* */
/* Input: */
/* addr Logical address of packed decimal storage operand */
/* len Length minus one of storage operand (range 0-15) */
/* dec A 31-byte area containing the decimal digits to be */
/* stored. Each byte contains one decimal digit in */
/* the low-order 4 bits of the byte. */
/* sign -1 if a negative sign is to be stored, or +1 if a */
/* positive sign is to be stored. */
/* */
/* A program check may be generated if the logical address */
/* causes an addressing, translation, or protection exception. */
/*-------------------------------------------------------------------*/
static void store_decimal (int32 addr, int32 len, uint8 *dec, int sign)
{
int i, j, a; /* Array subscripts */
j = len;
a = addr;
for (i = MAX_DECIMAL_DIGITS; i > -1; i--) {
if (j) {
PutMem(a, (dec[i-1] | 0xf0));
a--;
j--;
} else {
break;
}
}
if (sign == -1) {
PutMem(addr, (GetMem(addr) & 0x0f));
PutMem(addr, (GetMem(addr) | 0xf0));
}
} /* end function store_decimal */
/* CPU Device Control */
int32 cpu (int32 op, int32 m, int32 n, int32 data)
{
int32 iodata = 0;
switch (op) {
case 0x00: /* Start IO */
return SCPE_OK;
case 0x01: /* LIO */
return SCPE_OK;
case 0x02: /* TIO */
break;
case 0x03: /* SNS */
/* SNS CPU gets the data switches */
iodata = SR;
break;
case 0x04: /* APL */
break;
default:
break;
}
return ((SCPE_OK << 16) | iodata);
}
/* Null device */
int32 nulldev (int32 opcode, int32 m, int32 n, int32 data)
{
if (opcode == 1)
return SCPE_OK; /* Ok to LIO unconfigured devices? */
return STOP_INVDEV;
}
/* Reset routine */
t_stat cpu_reset (DEVICE *dptr)
{
int_req = 0;
level = 8;
sim_brk_types = sim_brk_dflt = SWMASK ('E');
return SCPE_OK;
}
/* Memory examine */
t_stat cpu_ex (t_value *vptr, t_addr addr, UNIT *uptr, int32 sw)
{
if (addr >= MEMSIZE) return SCPE_NXM;
if (vptr != NULL) *vptr = M[addr] & 0xff;
return SCPE_OK;
}
/* Memory deposit */
t_stat cpu_dep (t_value val, t_addr addr, UNIT *uptr, int32 sw)
{
if (addr >= MEMSIZE) return SCPE_NXM;
M[addr] = val & 0xff;
return SCPE_OK;
}
t_stat cpu_set_size (UNIT *uptr, int32 val, CONST char *cptr, void *desc)
{
int32 mc = 0;
uint32 i;
if ((val <= 0) || (val > MAXMEMSIZE) || ((val & 07777) != 0))
return SCPE_ARG;
for (i = val; i < MEMSIZE; i++) mc = mc | M[i];
if ((mc != 0) && (!get_yn ("Really truncate memory [N]?", FALSE)))
return SCPE_OK;
MEMSIZE = val;
for (i = MEMSIZE; i < MAXMEMSIZE; i++) M[i] = 0;
return SCPE_OK;
}
t_stat cpu_boot (int32 unitno, DEVICE *dptr)
{
level = 8;
IAR[8] = 0;
return SCPE_OK;
}