fix: немного расширил описание примера с inc

Обязательно понимание того, что я не проверял эти решения)

02-cpu-commnads/README.md

@@ -74,11 +74,95 @@
 
 NOTE: По какой-то причине это не указано в руководстве Intel, но по крайней мере если верить сайту, который я использовал для ассемблирования инструкций, то нужно обязательно учитыать префиксы к опкоду прежде чем начинать кодировать (опять же все по опыту):
 
-1. `0x67` - ставится если команда **адресуется** при помощи 32-битных регистров
-2. `0x66` - ставится, если программа иссользует хотя бы 1 16-битный регистр
+1. `0x66` - ставится, если программа иссользует хотя бы 1 16-битный регистр
+2. `0x67` - ставится если команда **адресуется** при помощи 32-битных регистров
 
 Благо для 8-битных операций другие опкоды и хотя бы на них не надо префиксы запоминать)
 
+## Примеры переводов 
+
+Голая теория никого никогда не радовала, поэтому постараюсь в меру своих сил переконвертировать несколько примеров
+
+**`mov rax, rbx`** - исходная инструкция
+
+Для начала в талмудике нам потребуется найти опкод операции. Поэтому ищем табличку для этой операции. В ней нас интересует один из двух покодов: `mov r/m64, r64` и `mov r64, r/m64`. Я возьму второй из этих вариантов, просто чтобы порядок следования регистров совпадал с нашей исходной иструкцией (потом поймете). Для выбранной инструкции приведен следующий opcode: `REX.W + 8B/r`
+
+Для начала посередине ставим опкод (8b в двоичной):
+
+[ 1000 1011 ]
+
+REX байт у нас появляется в любом случае. REX.W - это флаг для REX, который переназначает операнды в размеры 64 бита. Если бы оба наших регистра были бы 32 битные, то этого флага бы не было. Ну а раз REX у нас обязателен, то можно немного определиться, будут ли у нас еще какие-то флаги в этом байте. Еще какие-то флаги могут появиться если вы используете регистры r8-r15, в остальных случаях REX будет выглядеть как [ 0100 1000 ]. У нас эти регистры не используются, поэтому оставим его в таком виде
+
+Промежуточный результат: [ 0100 1000 ] [ 1000 1011 ]
+
+Далее ModR/M. Первые 2 бита от него определяют будут ли использовать адреса и смещения. Подробнее смотрите выше. В нашем случае мы пересылаем из регистра в регистр, поэтому нам нужен mod = 11. Далее идет поле рег. Конкретно в случае `mov r64, r/m64` по контексту можно догадаться что reg у нас слева. Тремя битами кодируется номер регистра. У rax номер 000, а у rbx номер 011. Как я уже и сказал, в нашем случае регистр приемника слева, поэтому ModR/M: [ 11 000 011 ]
+
+Итого: [ 0100 1000 ] [ 1000 1011 ] [ 11 000 011 ]
+
+*примечание: ответ мог бы получиться немного другой, если бы мы взяли первый попавшийся опкод, но можете использовать его в качестве упражнения (ну а что, составители учебника так могут, а я нет?)*
+
+**`mov r8, r11`**
+
+Все действия и рассуждения у нас аналогичны примеру выше. Я хотел лишь пару слов сказать о том, как кодировать регистры r8-r15. Как раз для этих целей нам поможет REX байт. Как я уже писал, REX имеет следующую структуру: 0100 WRXB. Бит R используется для расширения поля reg, а бит B используется для расширения поля r/m. Когда идет обращение к регистру из диапазона r8-r15 в соответствующих дополняющих байтах должна стоять единица. То есть r8 в поле reg будет записываться как REX.R == 1 + 000, а r11 в поле r/m как REX.B == 1 + 011. Так что для данной команды повторится все, кроме REX байта, который в свою очередь примет вид [ 0100 1101 ]
+
+Итого: [ 0100 1101 ] [ 1000 1011 ] [ 11 000 011 ]
+
+**`lea rbx, [rbp + r12 * 4 + 33]`**
+
+Для начала повторяем наш процесс поиска в талмудике опкода. В этот раз у нас разночтений нет, у нас есть только вариант с инструкцией `lea r64, m`. Для нее поле opcode выглядит довольно знакомо: `REX.W 8D /r`. REX байт у нас уже задействован и 100% появится, однако я вижу тут регистр r12, что должно сказать мне, что REX байт не ограничится простым [ 0100 1000 ]. Заполним мы его чуть позже, а пока только опкод. [ 1000 1101 ]
+
+Далее смотрим ModR/M. в нашем случае мы явно будем использовать адрес из оперативной памяти и число 33 для сдвига, поэтому нам нужен режим mod = 01 (можно и 10, но тогда будет куча бесполезных нулей). поле reg не вызывает вопросов - используется регистр rbx, поэтому в REX.R = 0, а reg = 011, а вот с полем r/m все любопытнее. Число, которое идет с плюсом можно пока мысленно вынести за скобки (но не убирать далеко, оно нам еще пригодится), а вот регистры мы уже не можем проморгать. Как мы помним поле r/m хранит только 3 бита, как же адресовать эту адову хренотень? Оказывается в r/m последовательность 100 зарезервирована под добавление еще одного байта - SIB байта. ModRM = [ 01 011 100 ]
+
+SIB байт состоит из 2 битов SS, которые представляют собой степень двойки, 2^(ss) я буду называть коэфициентом. В нашем случае хочу умножить на 4, поэтому ss = 10. Далее идет 3 бита на индекс - это регистр, который будет умножен на коэфициент. В нашем случае мы хотим умножить r12 на 4. Index регистр расширяется из REX.X (потому что inde**X**). Поэтому нам нужно записать двоичной системе 12 - 1100. Старший бит отправится в REX.X, а остальное в поле index, то есть REX.X == 1 index == 100. Далее идет 3 бита под регистр базы. Он расширяется из REX.B, в нашем случае хочется использовать регистр rbp, он имеет номер 0101, поэтому используем REX.B == 0, base == 101. SIB = [ 10 100 101 ]
+
+Уже на этом этапе мы видим, что нужно проставить еще одну единицу в REX.X, в остальных же местах используются обычные регистры, поэтому REX = [ 0100 1010 ]. 
+
+Помните, мы запоминали число 33? Ну вот настало его время. Дело в том, что число, которое надо прибавить к итоговому адресу. В нашем случае надо закодировать число 33, это будет 0b00100001, это мы засунем в displecement байт
+
+Итого: [ 0100 1010 ] [ 1000 1101 ] [ 01 011 100 ] [ 10 100 101 ] [ 0010 0001 ]
+
+**`inc WORD PTR [2 * rsi + 31]`**
+
+*Интересный факт, в качестве index не может использоваться rsp*
+
+Не буду много повторяться. Внутри опокад стоит `WORD PTR`, что значит, что я самолично попросил ассемблер относиться к содержимому скобок, как к указателю на 1 машинное слово. Возможно также отнестись как к указателю на байт `BYTE`, двойное слово `DWORD` и четверное слово `QWORD`. Instruction `inc r/m16`. Opcode `FF /0`. `/0` означает, что в ModR/M в поле reg нужно записать 3 нуля. Остальное адрессуется как обычно, поэтому самое время обсудить вот какую вещь. Если нам необходимо опустить базу, то в SIB байте мы поставим в поле base 101. Однако для этого в mod нужно поставить 00 и автоматически придется записать 4 байта смещения. 
+
+[ 0110 0110 ] [ 1111 1111 ] [ 00 000 100 ] [ 01 110 101 ] [ 0001 1111 ] [ 0000 0000 ] [ 0000 0000 ] [ 0000 0000 ]
+
+Замечу так же, что поскольку не используется ни REX.W ни один из расширенных регистров, REX байт принимал значение 0100 0000, но в таком случае спецификация Intel позволяет этот байт опускать. А вот что опускать нельзя - это префикс переназначения операнда, потому что используется 16 битный регистр.
+
+Число 31 у нас записано справа от SIB байта и у многих наверное появился вопрос, а почему оно выглядит имено так? А точнее - почему 3 последних байта заполнены нулями. Отвечаю - бог его знает и на самом деле, это зависит от процессора, и, возможно, от того, использует ли от little endian или big endian. Little endian - это когда число в памяти записывается как мы привыкли, то есть чем ливее циферка, тем она значительнее. Так что 0x1c1b так в память и запишутся - [ 0001 1100 ] [ 0001 1011 ]. Но вот в случае big endian запись идет по байтам, и если внутри байта все стандартно, то вот сами байты идут уже от младшего к старшему, поэтому то же число запишется уже в обратном порядке как [ 0001 1011 ] [ 0001 1100 ]. Думаю тут такая же фигня
+
+Однако тут есть еще один важный момент Мы видим, что в данном случае есть один интересный момент. Вроде mod == 00, но тут 4 байта dispasement. Дело в том, что если mod == 00 а base == 101, то будет адресация вида index * scale + disp32. Довольно весело. Это я к чему? даже если вы знаете все номера регистры, таблицу смотреть все равно надо
+
+**Послесловие**
+
+Это далеко не исчерпывающий набор примеров, но этого хватит для начала.
+
+## Решение остальных пунктов
+
+*В целом в этом репозитории лежат файлы, в которых я приложил пока еще не протестированное, но решение для первых нескольких пунктов. Однако в силу того, что память у нас 64-битная, а также я не могу залеть напрямую в видеопамять если не буду собирать модуль ядра. Возможно конечно от нечего делать я сделаю модуль ядра, который позволит выворачивать такие приколы, но это будет точно не на время этого курса.*
+
+### 01 - простучать команды ассемблеру
+
+Тут нечего сказать - есть просто колонка с коммандами и просят их использовать. Тут гугл в помощь.
+
+А вот по поводу полей в команде могу сразу сказать - в 64 битном процессоре все это будет выглядеть немного иначе. Поэтому предлагаю 16-битные регистры заменить в команде на 64 битные и закодировать как для 64 разрядной системы. подробная инструкция как это бы надо бы сделать у меня приведена выше, поэтому тут не буду на этом останаваливаться.
+
+### 02 - Пересылка массива при помощи loop и lea
+
+`lea` - это сокращение от "load effective adress". Она использует использует классическую операцию обращения к памяти, но саму память не затрагивает, а просто записывает высчитанный адрес в переменную. `loop` в свою очередь прыгает на определенную метку пока в rcx не окажется 0 и при каждом прыжке уменьшает значение в rcx на 1.
+
+### 03 - Пересылка данных через LODS, MOVS, STOS
+
+LODS и STOS - парные команды. Первая читает из памяти в rax (или его часть), STOS наоборот - пишет в память содержимое rax (или его часть). `movs` перемещает содержимое из [rsi] в [rdi], после чего увеличивает адрес на размер элемента. Это очень хорошо сочетается с префиксом rep, который заставляет повторяет команду пока в rcx не будет 0, а после каждого повторения уменьшает rcx на 1 
+
+### 05 - Запись в произвольную память
+
+В линуксе вся память виртуальная, а если попытаться в лоб попробовать написать что-то в рандомный адрес, ядро выдаст segfault. Чтобы этого не произошло необходимо промапать память. Для этого используется системный вызов mmap, про его особенности написано внутри файла. Здесь хотелось бы пояснить вот какой момент: этот системный вызов использует кучу флагов, которые изначально не особенно нам известны. Так вот. Самый быстрый способ найти их - обратиться к include вашего компилятора. Для mmap все лежит в файле <sys/mmap.h>. Эти значения я решил занести в define, чтобы код был чуть читаемее
+
+У mmap есть и другая особенность - он мапает виртуальную память, а не физическую, поэтому то, что в оригинальной методичке мы на самом деле использовали видеобуфер, для нас не имеет реального значения. Я также использовал анонимный приватный маппинг, чтобы не портить жизнь другим процессам и не грузить ничего из файла, поэтому даже попортить жизнь другим процессам у меня не получится
+
 <!--- Пока что я думаю эта инфа лишняя, может потом верну и раскомментирую
 ### Чутка про префикс REX
 

02-cpu-commnads/hex2bin.py

@@ -4,8 +4,8 @@ import argparse
 def hex2bin(hexNum: str) -> None:
     return bin(int(hexNum, 16))
 
-parser = argparse.ArgumentParser(description="convert hex number to bin right in terminal")
-parser.add_argument('-s', '--stdin', action='store_true', help="if passed takes input from terminal arguments")
+parser = argparse.ArgumentParser(description="Convert hex number to bin right in terminal")
+parser.add_argument('-s', '--stdin', action='store_true', help="if passed takes input from stdin")
 parser.add_argument('number', nargs='?')
 
 args = parser.parse_args()

02-cpu-commnads/task2.asm

@@ -0,0 +1,29 @@
+global _start
+
+section .data
+
+  source: db 1, 2, 3, 4, 5, 6, 7, 8
+  s_size equ $-source
+
+section .bss
+
+  dest: resb 8
+
+section .text
+
+_start:
+
+  lea rsi, [source]
+  lea rdi, [dest]
+  mov rcx, s_size
+  
+  .loop:
+
+  mov al, [rsi + rcx]
+  mov [rdi + rcx], al
+
+  loop .loop
+
+  mov rax, 60
+  mov rdi, 0
+  syscall

02-cpu-commnads/task3.asm

@@ -0,0 +1,25 @@
+global _start
+
+section .data
+  source: db 1, 2, 3, 4, 5, 6, 7, 8
+  s_size equ $-source
+
+section .bss
+
+  dest: resb 8
+
+section .text
+
+_start:
+
+  mov rsi, source
+  mov rdi, dest
+  mov rcx, s_size
+  
+  .loop:
+  rep movsb
+  loop .loop
+
+  mov rax, 60
+  mov rdi, 0
+  syscall

02-cpu-commnads/task5.asm

@@ -0,0 +1,64 @@
+global _start
+
+section .text
+
+%define SRC 0xB8000
+%define DST 0xB9000
+%define ARR_SIZE 10
+
+%define PROT_READ       0x1
+%define PROT_WRITE      0x2
+%define MAP_PRIVATE     0x02
+%define MAP_ANONYMOUS   0x20
+
+_start:
+
+  ; Из-за особенностей ядра линукса нужно сначала промапать произвольную память
+  mov rax, 0x9 ; mmap
+  mov rdi, SRC ; где
+  mov rsi, ARR_SIZE ; сколько
+  mov rdx, PROT_READ ; флаги чтения
+  or  rdx, PROT_WRITE ; флаги записи
+  mov r10, MAP_PRIVATE ; приватная память
+  or  r10, MAP_ANONYMOUS ; не связана с файлом
+  mov r9,  0 ; офсет должен быть 0
+  syscall
+  
+  
+  mov rsi, rax ; ставлю так, так как ядро линукса выделяет ближайшую область памяти, а не точно заказанную - проклятое выравнивание
+
+  ; заполню чем-нибудь массив
+  mov rcx, ARR_SIZE
+  mov rbx, 0
+  
+  .fill_src_loop:
+
+  mov [rsi + rbx], bl
+  inc rbx
+    
+  loop .fill_src_loop
+
+  push rsi
+
+  mov rax, 0x9 ; mmap
+  mov rdi, DST ; где
+  mov rsi, ARR_SIZE ; сколько
+  mov rdx, PROT_WRITE ; флаги чтения
+  ; or  rdx, PROT_WRITE ; флаги записи
+  mov r10, MAP_PRIVATE ; приватная память
+  or  r10, MAP_ANONYMOUS ; не связана с файлом
+  mov r9,  0 ; офсет должен быть 0
+  syscall
+
+  mov rdi, rax
+  ; заполню чем-нибудь массив
+
+  mov rcx, ARR_SIZE ; сколько байт копируем
+
+  pop rsi
+  rep movsb
+
+  mov rax, 60
+  mov rdi, 0
+  syscall
+