Как я могу написать интерпретатор для 'eq' для языка Hack Assembly?

Похоже, есть еще одна глава, которая более определенно определяет Hack CPU. Он говорит:

Hack CPU состоит из ALU, указанного в главе 2, и трех регистров, называемых регистром данных (D), адресным регистром (A) и программным счетчиком (PC). D и A - это 16-разрядные регистры общего назначения, которыми можно управлять с помощью арифметических и логических инструкций, таких как A = D-1, D = D | A и т. Д., В соответствии с машинным языком Hack, указанным в главе 4. В то время как D -register используется исключительно для хранения значений данных, содержимое A-регистра можно интерпретировать тремя разными способами, в зависимости от контекста инструкции: как значение данных, как адрес RAM или как адрес ROM

Таким образом, очевидно, что "M" обращаются к участкам ОЗУ, контролируемым A. Я пропустил косвенную адресацию. Теперь все щелкает.

Когда эта путаница прояснилась, теперь мы можем справиться с вопросом OP (намного проще).

Начнем с реализации вызовов подпрограмм со стеком.

     ; subroutine calling sequence
     @returnaddress   ; sets the A register
     D=A
     @subroutine
     0 ; jmp
  returnaddress:

     ...

  subroutine: ; D contains return address
  ; all parameters must be passed in memory locations, e.g, R1-R15
  ; ***** subroutine entry code *****
     @STK
     AM=M+1         ; bump stack pointer; also set A to new SP value
     M=D            ; write the return address into the stack
  ; **** subroutine entry code end ***
     <do subroutine work using any or all registers>
  ; **** subroutine exit code ****
     @STK
     AM=M-1         ; move stack pointer back
     A=M            ; fetch entry from stack
     0; jmp         ; jmp to return address
  ; **** subroutine exit code end ****

Инструкцию push constant можно легко преобразовать для сохранения в динамическое место в стеке:

     @<constant>  ; sets A register
     D=A         ; save the constant someplace safe
     @STK
     AM=M+1         ; bump stack pointer; also set A to new SP value
     M=D            ; write the constant into the stack

Если бы мы хотели создать подпрограмму для передачи констант:

   pushR2: ; value to push in R2
     @R15           ; save return address in R15
     M=D            ; we can't really use the stack,...
     @R2            ; because we are pushing on it
     D=M
     @STK
     AM=M+1         ; bump stack pointer; also set A to new SP value
     M=D            ; write the return address into the stack
     @R15
     A=M
     0 ; jmp

И чтобы вызвать подпрограмму "push constant":

     @<constant>
     D=A
     @R2
     M=D
     @returnaddress   ; sets the A register
     D=A
     @pushR2
     0 ; jmp
  returnaddress:

Чтобы протолкнуть значение переменной X:

     @X
     D=M
     @R2
     M=D
     @returnaddress   ; sets the A register
     D=A
     @pushR2
     0 ; jmp
  returnaddress:

Подпрограмма для извлечения значения из стека в регистр D:

   popD:
     @R15           ; save return address in R15
     M=D            ; we can't really use the stack,...
     @STK
     AM=M-1         ; decrement stack pointer; also set A to new SP value
     D=M            ; fetch the popped value
     @R15
     A=M
     0 ; jmp

Теперь, чтобы выполнить вычисление "EQ", которое было исходным запросом OP:

EQ: ; compare values on top of stack, return boolean in D
      @R15         ; save return address
      M=D
      @EQReturn1
      D=A
      @PopD
      0; jmp
@EQReturn1:
      @R2
      M=D        ; save first popped value
      @EQReturn2
      D=A
      @PopD
      0; jmp
@EQReturn2:
      ; here D has 2nd popped value, R2 has first
      @R2
      D=D-M
      @EQDone
      equal; jmp
      @AddressOfXFFFF
      D=M
EQDone: ; D contains 0 or FFFF here
      @R15
      A=M         ; fetch return address
      0; jmp

Собираем все вместе:

     @5           ; push constant 5
     D=A
     @R2
     M=D
     @returnaddress1
     D=A
     @pushR2
     0 ; jmp
  returnaddress1:

     @X                ; now push X
     D=M
     @R2
     M=D
     @returnaddress2 
     D=A
     @pushR2
     0 ; jmp
  returnaddress2:

     @returnaddress3   ; pop and compare the values
     D=A
     @EQ
     0 ; jmp
  returnaddress3:

На этом этапе OP может сгенерировать код для помещения D в стек:

     @R2                ; push D onto stack
     M=D
     @returnaddress4 
     D=A
     @pushR2
     0 ; jmp
  returnaddress4:

или он может сгенерировать код для перехода по значению D:

     @jmptarget
     EQ ; jmp

Как я писал в последнем комментарии, существует способ без ветки, поэтому вам нужно вычислить возвращаемое значение напрямую из операндов.

Давайте пока возьмем простую операцию, например eq

• если я правильно понял eq a,d это что-то вроде a=(a==d)
• истина - 0xFFFF, ложь - 0x0000

• Итак, если a==d, то a-d==0 это можно использовать напрямую

  1. compute a=a-d

  2. вычислить OR каскад всех битов a

     • if the result is 0 return 0
     • если результат 1, возврат 0xFFFF
     • это может быть достигнуто таблицей или 0-OR_Cascade(a)

  3. OR каскад

     • I do not see any bit shift operations in your description
     • поэтому вам нужно использовать a+a вместо a<<1
     • и если необходим сдвиг вправо, вам нужно реализовать деление на 2

Итак, когда я резюмирую, это eq a,d может выглядеть так:

• a=a-d;
• a=(a|(a>>1)|(a>>2)|...|(a>>15))&1
• a=0-a;
• вам просто нужно закодировать это в свою сборку
• поскольку у вас нет прямой поддержки разделения или смены, возможно, это будет лучше
• a=a-d;
• a=(a|(a<<1)|(a<<2)|...|(a<<15))&0x8000
• a=0-(a>>15);

меньшее и большее сравнение намного сложнее

• вам нужно вычислить флаг переноса вычитания
• или используйте знак результата (MSB результата)
• если вы ограничиваете операнды до 15 бит, то это всего лишь 15 бит
• для полных 16-битных операндов вам нужно вычислить 16-й бит результата
• для этого вам нужно немного знать логические схемы и принципы суммирования ALU
• или разделите значения на 8-битные пары и выполните каскад вычитания 2x8 бит
• итак a=a-d станет:
• sub al,dl
• sbc ah,dh
• и перенос / знак находится в 8-м бите результата, который доступен