Inspect register contents during mmix interactive mode

Question

I want to know how I can use mmix in interactive mode to display the contents of registers whenever I ask to see them. For example, I have a simple mmix program:

% Compute D=4A-2B+16C
%LABEL      OPCode      Operands        Comments
            LOC         Data_Segment
            GREG        @
A           OCTA        3          Reserve an octabyte for A
B           OCTA        #10        Reserve an octabyte for B
C           OCTA        2          Reserve an octabyte for C
D           OCTA        0          Reserve an octabyte for D

            LOC         #100            start assembly instructions
Main        LDO         $0,A            $0 contents of A
            LDO         $1,B            $1 contents of B
            LDO         $2,C            $2 contents of C
            SL          $0,$0,2         $0 = 4*$0
            SL          $1,$1,1         $1 = 2*$1
            SL          $2,$2,4         $2 = 16*$2
            SUB         $0,$0,$1        $0 < 4A-2B
            ADD         $0,$0,$2        $0 < 4A-2B+16C
            STO         $0,D            store answer in D

and I can run mmix -i myprog.mmo to get the output:

mmix> 
           (00000000000000fc: fb0000ff (UNSAVE)) #6000000000000088: rG=254, ..., rL=2
  0 instructions, 0 mems, 0 oops; 0 good guesses, 0 bad
  (now at location #0000000000000100)
mmix> 
         1. 0000000000000100: 8d00fe00 (LDOI) $0=l[0] = M8[#2000000000000000] = 3
  1 instruction, 1 mem, 1 oop; 0 good guesses, 0 bad
  (now at location #0000000000000104)
mmix> 
         1. 0000000000000104: 8d01fe08 (LDOI) $1=l[1] = M8[#2000000000000000+8] = 16
  2 instructions, 2 mems, 2 oops; 0 good guesses, 0 bad
  (now at location #0000000000000108)
mmix> 
         1. 0000000000000108: 8d02fe10 (LDOI) rL=3, $2=l[2] = M8[#2000000000000000+16] = 2
  3 instructions, 3 mems, 3 oops; 0 good guesses, 0 bad
  (now at location #000000000000010c)
mmix> 
         1. 000000000000010c: 39000002 (SLI) $0=l[0] = 3 << 2 = 12
  4 instructions, 3 mems, 4 oops; 0 good guesses, 0 bad
  (now at location #0000000000000110)
mmix> 
         1. 0000000000000110: 39010101 (SLI) $1=l[1] = 16 << 1 = 32
  5 instructions, 3 mems, 5 oops; 0 good guesses, 0 bad
  (now at location #0000000000000114)
mmix> 
         1. 0000000000000114: 39020204 (SLI) $2=l[2] = 2 << 4 = 32
  6 instructions, 3 mems, 6 oops; 0 good guesses, 0 bad
  (now at location #0000000000000118)
mmix> 
         1. 0000000000000118: 24000001 (SUB) $0=l[0] = 12 - 32 = -20
  7 instructions, 3 mems, 7 oops; 0 good guesses, 0 bad
  (now at location #000000000000011c)
mmix> 
         1. 000000000000011c: 20000002 (ADD) $0=l[0] = -20 + 32 = 12
  8 instructions, 3 mems, 8 oops; 0 good guesses, 0 bad
  (now at location #0000000000000120)
mmix> 
         1. 0000000000000120: ad00fe18 (STOI) M8[#2000000000000000+24] = 12
  9 instructions, 4 mems, 9 oops; 0 good guesses, 0 bad
  (now at location #0000000000000124)
mmix> 
         1. 0000000000000124: 00000000 (TRAP) Halt(0)
  10 instructions, 4 mems, 14 oops; 0 good guesses, 0 bad
  (halted at location #0000000000000124)
mmix> 
  10 instructions, 4 mems, 14 oops; 0 good guesses, 0 bad
  (halted at location #0000000000000124)

Which is all good and well. But what do I need to do if I want to inspect the contents of some register in the middle of running this interactively? Also, how about seeing the contents in hex instead of decimal?

Answer 1

For those who are interested, apparently not many :) , the information I was looking for can be found at the MMIX documentation site. Then check out the mmix-sim.pdf file on page 3.

In particular, to inspect a local register, in the simulator type

l0

to see local register $0 contents in decimal. If you want to set the local register to something, it's simply

l0=27.0

so now $0 is the 64bit floating point representation of 27.0! If you want to see hex, just do

l0#.

The rest you all can read for yourself. Documentation includes how to set breakpoints, etc.