I can’t name that system, but I have used a system that features 2 instructions per line - the Intel i860.
It had a dual-instruction mode where the CPU would read a 64-bit word that represented 2 x 32-bit instructions - one for the Integer unit and anther for the floating point unit. The instructions would be executed in parallel.
That doesn’t look like i860 code, but it’s been many years and I lost a lot of the old grey cells to it…
I can’t name it either, but I offer the Elliott 803 as seen at TNMoC:
The Elliott 803 Instruction Set
An Elliott 803 instruction consists of two parts, the opcode, which is defined by 6 bits, and the address, which takes 13 bits. Together these 19 bits can be packed two to a 39-bit word, with an extra bit in between. This extra bit is known as the B-modifier, and, if the bit is a one, it causes the second instruction in the word to be modified by adding the contents of the location specified in the address of the first instruction.
One would be 6502 assembly in BBC BASIC. As this is wrapped in BASIC, this still supports multiple instructions in a line (separated by a colon). Labels are prefixed by a dot, though. So it looks different from your example.
Here’s a rather wierd example (The BASIC integer variable “P%” is also the program counter. Assigning to “$P%” – actuially a BBC BASIC indirection – insterts a string of characters, but also requires some updating to the program counter. Later versions of BBC BASIC had a more comfortable method for this.)
100 REM THIS IS BASIC
110 P% = &4000 : REM SET LOCATION COUNTER
120 TARGET = &4100 : REM A VARIABLE
130 FOR C=0 TO 2 STEP 2 : REM PASS LOOP
140 [OPT C \now in asm mode, also setting an option
150 LDX #&20 \copy 32 bytes
160 .LOOP LDA SOURCE,X
170 STA TARGET,X
180 DEX:BNE LOOP \two in a row!
190 .SOURCE
200 ]NEXT : REM BACK TO BASIC
210 $P%=":-) "+STRING$(28,"*") : REM INSERT SOME CHARS AT .SOURCE
220 P%=P%+LEN($P%) : REM UPDATE LOCATION
230 END
I knew, that here are experts. Yes it’s the Elliott 803. I found 3 emulators.
One is a virtual 3D simulator. I haven’t checked that.
One is an old ~2011 emulator for BSD. I couldn’t compile that.
And one is a modern one with GUI under JAVA. That worked, takes some time to start.
You can open a core dump file (.803) and tape files (.tape, unknown short binary).
There are assembly files (*.a1) and Algol files *.algol.
The BSD emulator uses *.h-code and *.elliott for ASM files, *.a60 for Algol and has *.hex5 and *.hex8 files (one byte per line) and scripts.
Interesting is the control panel with a very large operate/enter key below and that it also used 35mm film tapes.
This is the commented source above (charset. a1) (C) Copyright Tim Baldwin 2009
**
* Procedure call example
*
* Prints the character set to the teletype
**
@entry * Entry point
entry: 00 LS / 74 4096 * Print letter shift
73 link : 40 chars * Procedure call to write characters
00 FS / 74 4096 * Print figure shift
73 link : 40 chars * Procedure call
72 8191 * Exit
link: 0 * Stores return address
chars: 26 ch : 32 ch * Clear ch, increment ch
05 max : 42 rtn * Check for end
00 ch / 74 4096 * Write character
74 4124 : 44 chars * Write space and loop
rtn: 74 4125 : 74 4126 * Write final CR LF
00 link / 40 1 * Return to address in link plus 1
ch: 0 * Workspace
max: 26 * Last character value
LS: 31 * Letter shift
FS: 27 * Figure shift
There are few samples. One is a music playing code.
Ah, nice! It’s an example of a machine with a nice front panel that - for me - gives a visual reminder of this odd aspect. Here’s Peter Onion, one of the curators:
I am reminded of the Playstation 2 VPU1 which was a 32 bit VLIW-SIMD vector unit. It has two instructions per line in its assembly language which executed simultaneously as it had two execution units. When programming you tried to make as much use of the processor as possible by not putting NOPs in either column. But sometimes there was no choice due to data hazards or other constraints.
