ЛР14,16. Исправление обработчика перехватов

При реализации обработчика намеренно не было реализовано сохранение
необерегаемых регистров. Так было сделано в виду неправильной
интерпретации EABI.
При входе в низкоуровневый обработчик необходимо сохранять весь
регистровый файл.

Author: HepoH3

Labs/14. Programming/README.md

@@ -360,22 +360,16 @@ _endless_loop:
 #     качестве аргумента.
 # В основе кода лежит обработчик из репозитория urv-core:
 # https://github.com/twlostow/urv-core/blob/master/sw/common/irq.S
-# Из реализации убраны сохранения нереализованных CS-регистров. Кроме того,
-# судя по документу приведенному ниже, обычное ABI подразумевает такое же
-# сохранение контекста, что и при программном вызове (EABI подразумевает ещё
-# меньшее сохранение контекста), поэтому нет нужды сохранять весь регистровый
-# файл.
-# Документ:
-#  https://github.com/riscv-non-isa/riscv-eabi-spec/blob/master/EABI.adoc
+# Из реализации убраны сохранения нереализованных CS-регистров.
 _int_handler:
   # Данная операция меняет местами регистры sp и mscratch.
   # В итоге указатель на стек прерываний оказывается в регистре sp, а вершина
   # программного стека оказывается в регистре mscratch.
   csrrw sp, mscratch, sp
 
   # Далее мы поднимаемся по стеку прерываний и сохраняем все регистры.
-  addi  sp, sp, -80 # Указатель на стек должен быть выровнен до 16 байт, поэтому
-                    # поднимаемся вверх не на 76, а на 80.
+  addi  sp, sp, -144 # Указатель на стек должен быть выровнен до 16 байт, поэтому
+                     # поднимаемся вверх не на 136, а на 144.
   sw    ra, 4(sp)
   # Мы хотим убедиться, что очередное прерывание не наложит стек прерываний на
   # программный стек, поэтому записываем в освободившийся регистр низ
@@ -387,32 +381,46 @@ _int_handler:
   la    ra, _stack_ptr
   blt   sp, ra, _endless_loop
 
-  sw    t0,12(sp) # Мы перепрыгнули через смещение 8, поскольку там должен
+  sw    gp,12(sp) # Мы перепрыгнули через смещение 8, поскольку там должен
                   # лежать регистр sp, который ранее сохранили в mscratch.
                   # Мы запишем его на стек чуть позже.
-  sw    t1,16(sp)
-  sw    t2,20(sp)
-  sw    a0,24(sp)
-  sw    a1,28(sp)
-  sw    a2,32(sp)
-  sw    a3,36(sp)
-  sw    a4,40(sp)
-  sw    a5,44(sp)
-  sw    a6,48(sp)
-  sw    a7,52(sp)
-  sw    t3,56(sp)
-  sw    t4,60(sp)
-  sw    t5,64(sp)
-  sw    t6,68(sp)
+  sw    tp,16(sp)
+  sw    t0,20(sp)
+  sw    t1,24(sp)
+  sw    t2,28(sp)
+  sw    s0,32(sp)
+  sw    s1,36(sp)
+  sw    a0,40(sp)
+  sw    a1,44(sp)
+  sw    a2,48(sp)
+  sw    a3,52(sp)
+  sw    a4,56(sp)
+  sw    a5,60(sp)
+  sw    a6,64(sp)
+  sw    a7,68(sp)
+  sw    s2,72(sp)
+  sw    s3,76(sp)
+  sw    s4,80(sp)
+  sw    s5,84(sp)
+  sw    s6,88(sp)
+  sw    s7,92(sp)
+  sw    s8,96(sp)
+  sw    s9,100(sp)
+  sw    s10,104(sp)
+  sw    s11,108(sp)
+  sw    t3,112(sp)
+  sw    t4,116(sp)
+  sw    t5,120(sp)
+  sw    t6,124(sp)
 
   # Кроме того, мы сохраняем состояние регистров прерываний на случай, если
   # произойдет ещё одно прерывание.
   csrr  t0,mscratch
   csrr  t1,mepc
   csrr  a0,mcause
   sw    t0,8(sp)
-  sw    t1,72(sp)
-  sw    a0,76(sp)
+  sw    t1,128(sp)
+  sw    a0,132(sp)
 
   # Вызов высокоуровневого обработчика прерываний.
   # Для того чтобы программа скомпоновалась, где-то должна быть описана
@@ -426,28 +434,42 @@ _int_handler:
   # сохраним его в регистр a0, и будем восстанавливаться из него.
   mv    a0,sp
 
-  lw    t1,72(a0)
-  addi  sp,sp,80
+  lw    t1,128(a0)
+  addi  sp,sp,144
   csrw  mscratch,sp
   csrw  mepc,t1
   lw    ra,4(a0)
   lw    sp,8(a0)
-  lw    t0,12(a0)
-  lw    t1,16(a0)
-  lw    t2,20(a0)
-  lw    a1,28(a0)   # Мы пропустили a0, потому что сейчас он используется в
+  lw    gp,12(a0)
+  lw    tp,16(a0)
+  lw    t0,20(a0)
+  lw    t1,24(a0)
+  lw    t2,28(a0)
+  lw    s0,32(a0)
+  lw    s1,36(a0)
+  lw    a1,44(a0)   # Мы пропустили a0, потому что сейчас он используется в
                     # качестве указателя на верхушку стека и не может быть
                     # восстановлен.
-  lw    a2,32(a0)
-  lw    a3,36(a0)
-  lw    a4,40(a0)
-  lw    a5,44(a0)
-  lw    a6,48(a0)
-  lw    a7,52(a0)
-  lw    t3,56(a0)
-  lw    t4,60(a0)
-  lw    t5,64(a0)
-  lw    t6,68(a0)
+  lw    a2,48(a0)
+  lw    a3,52(a0)
+  lw    a4,56(a0)
+  lw    a5,60(a0)
+  lw    a6,64(a0)
+  lw    a7,68(a0)
+  lw    s2,72(a0)
+  lw    s3,76(a0)
+  lw    s4,80(a0)
+  lw    s5,84(a0)
+  lw    s6,88(a0)
+  lw    s7,92(a0)
+  lw    s8,96(a0)
+  lw    s9,100(a0)
+  lw    s10,104(a0)
+  lw    s11,108(a0)
+  lw    t3,112(a0)
+  lw    t4,116(a0)
+  lw    t5,120(a0)
+  lw    t6,124(a0)
   lw    a0,40(a0)
 
   # Выход из обработчика прерывания

Labs/14. Programming/startup.S

@@ -57,22 +57,16 @@ _endless_loop:
 #     качестве аргумента.
 # В основе кода лежит обработчик из репозитория urv-core:
 # https://github.com/twlostow/urv-core/blob/master/sw/common/irq.S
-# Из реализации убраны сохранения нереализованных CS-регистров. Кроме того,
-# судя по документу приведенному ниже, обычное ABI подразумевает такое же
-# сохранение контекста, что и при программном вызове (EABI подразумевает еще
-# меньшее сохранение контекста), поэтому нет нужды сохранять весь регистровый
-# файл.
-# Документ:
-#  https://github.com/riscv-non-isa/riscv-eabi-spec/blob/master/EABI.adoc
+# Из реализации убраны сохранения нереализованных CS-регистров.
 _int_handler:
   # Данная операция меняет местами регистры sp и mscratch.
   # В итоге указатель на стек прерываний оказывается в регистре sp, а вершина
   # программного стека оказывается в регистре mscratch.
-  csrrw sp, mscratch,sp
+  csrrw sp, mscratch, sp
 
   # Далее мы поднимаемся по стеку прерываний и сохраняем все регистры.
-  addi  sp, sp, -80  # Указатель на стек должен быть выровнен до 16 байт, поэтому
-                     # поднимаемся вверх не на 76, а на 80.
+  addi  sp, sp, -144 # Указатель на стек должен быть выровнен до 16 байт, поэтому
+                     # поднимаемся вверх не на 136, а на 144.
   sw    ra, 4(sp)
   # Мы хотим убедиться, что очередное прерывание не наложит стек прерываний на
   # программный стек, поэтому записываем в освободившийся регистр низ
@@ -84,32 +78,46 @@ _int_handler:
   la    ra, _stack_ptr
   blt   sp, ra, _endless_loop
 
-  sw    t0, 12(sp) # Мы перепрыгнули через смещение 8, поскольку там должен
-                   # лежать регистр sp, который ранее сохранили в mscratch.
-                   # Мы запишем его на стек чуть позже.
-  sw    t1, 16(sp)
-  sw    t2, 20(sp)
-  sw    a0, 24(sp)
-  sw    a1, 28(sp)
-  sw    a2, 32(sp)
-  sw    a3, 36(sp)
-  sw    a4, 40(sp)
-  sw    a5, 44(sp)
-  sw    a6, 48(sp)
-  sw    a7, 52(sp)
-  sw    t3, 56(sp)
-  sw    t4, 60(sp)
-  sw    t5, 64(sp)
-  sw    t6, 68(sp)
+  sw    gp,12(sp) # Мы перепрыгнули через смещение 8, поскольку там должен
+                  # лежать регистр sp, который ранее сохранили в mscratch.
+                  # Мы запишем его на стек чуть позже.
+  sw    tp,16(sp)
+  sw    t0,20(sp)
+  sw    t1,24(sp)
+  sw    t2,28(sp)
+  sw    s0,32(sp)
+  sw    s1,36(sp)
+  sw    a0,40(sp)
+  sw    a1,44(sp)
+  sw    a2,48(sp)
+  sw    a3,52(sp)
+  sw    a4,56(sp)
+  sw    a5,60(sp)
+  sw    a6,64(sp)
+  sw    a7,68(sp)
+  sw    s2,72(sp)
+  sw    s3,76(sp)
+  sw    s4,80(sp)
+  sw    s5,84(sp)
+  sw    s6,88(sp)
+  sw    s7,92(sp)
+  sw    s8,96(sp)
+  sw    s9,100(sp)
+  sw    s10,104(sp)
+  sw    s11,108(sp)
+  sw    t3,112(sp)
+  sw    t4,116(sp)
+  sw    t5,120(sp)
+  sw    t6,124(sp)
 
   # Кроме того, мы сохраняем состояние регистров прерываний на случай, если
-  # произойдет еще одно прерывание.
-  csrr  t0, mscratch
-  csrr  t1, mepc
-  csrr  a0, mcause
-  sw    t0, 8(sp)
-  sw    t1, 72(sp)
-  sw    a0, 76(sp)
+  # произойдет ещё одно прерывание.
+  csrr  t0,mscratch
+  csrr  t1,mepc
+  csrr  a0,mcause
+  sw    t0,8(sp)
+  sw    t1,128(sp)
+  sw    a0,132(sp)
 
   # Вызов высокоуровневого обработчика прерываний.
   # Для того чтобы программа скомпоновалась, где-то должна быть описана
@@ -119,33 +127,47 @@ _int_handler:
   # Восстановление контекста. В первую очередь мы хотим восстановить CS-регистры,
   # на случай, если происходило вложенное прерывание. Для этого, мы должны
   # вернуть исходное значение указателя стека прерываний. Однако его нынешнее
-  # значение нам еще необходимо для восстановления контекста, поэтому мы
+  # значение нам ещё необходимо для восстановления контекста, поэтому мы
   # сохраним его в регистр a0, и будем восстанавливаться из него.
   mv    a0,sp
 
-  lw    t1, 72(a0)
-  addi  sp, sp, 80
-  csrw  mscratch, sp
-  csrw  mepc, t1
-  lw    ra, 4(a0)
-  lw    sp, 8(a0)
-  lw    t0, 12(a0)
-  lw    t1, 16(a0)
-  lw    t2, 20(a0)
-  lw    a1, 28(a0)   # Мы пропустили a0, потому что сейчас он используется в
-                     # качестве указателя на верхушку стека и не может быть
-                     # восстановлен.
-  lw    a2, 32(a0)
-  lw    a3, 36(a0)
-  lw    a4, 40(a0)
-  lw    a5, 44(a0)
-  lw    a6, 48(a0)
-  lw    a7, 52(a0)
-  lw    t3, 56(a0)
-  lw    t4, 60(a0)
-  lw    t5, 64(a0)
-  lw    t6, 68(a0)
-  lw    a0, 40(a0)
+  lw    t1,128(a0)
+  addi  sp,sp,144
+  csrw  mscratch,sp
+  csrw  mepc,t1
+  lw    ra,4(a0)
+  lw    sp,8(a0)
+  lw    gp,12(a0)
+  lw    tp,16(a0)
+  lw    t0,20(a0)
+  lw    t1,24(a0)
+  lw    t2,28(a0)
+  lw    s0,32(a0)
+  lw    s1,36(a0)
+  lw    a1,44(a0)   # Мы пропустили a0, потому что сейчас он используется в
+                    # качестве указателя на верхушку стека и не может быть
+                    # восстановлен.
+  lw    a2,48(a0)
+  lw    a3,52(a0)
+  lw    a4,56(a0)
+  lw    a5,60(a0)
+  lw    a6,64(a0)
+  lw    a7,68(a0)
+  lw    s2,72(a0)
+  lw    s3,76(a0)
+  lw    s4,80(a0)
+  lw    s5,84(a0)
+  lw    s6,88(a0)
+  lw    s7,92(a0)
+  lw    s8,96(a0)
+  lw    s9,100(a0)
+  lw    s10,104(a0)
+  lw    s11,108(a0)
+  lw    t3,112(a0)
+  lw    t4,116(a0)
+  lw    t5,120(a0)
+  lw    t6,124(a0)
+  lw    a0,40(a0)
 
   # Выход из обработчика прерывания
   mret