docs: пояснил по поводу Makefile в README

Прототип еще не тестировался

03-asm-bios/Makefile

@@ -0,0 +1,13 @@
+ASM = nasm
+ASM_FLAGS = -felf64 -g
+LINK = ld
+
+%: %.o
+	$(LINK) -o $@ $^
+
+%.o: %.asm
+	$(ASM) $(ASM_FLAGS) $^ -o $@
+
+clean:
+	rm -f *.o
+	rm -f $(subst .asm, $(empty), $(wildcard *.asm))

03-asm-bios/README.md

@@ -2,3 +2,13 @@
 
 ## Ассемблер и функции BIOS
 
+В этой работе намного проще посмотреть непосредственно решения и почитать комментарии к коду, чем читать теоретическое приложение к работе. Если вам все же что-то не понятно - кидайте в issues
+
+Впрочем зная, что основная масса народу не будет делать эту лабу так, как сделал ее я, сюда вряд ли кто-то заглянет)
+
+### Касаемо Makefile
+
+Для того чтобы не писать много команд для однотипной и монотонной сборки проекта, был написан простой Makefile. Однако работает он следующим образом: он принимает название цели сборки и ищет файл с именем цели и расширением .asm. Если не находит - не собирает цель.
+
+Важно заметить, что он не умеет линковать другие файлы в ассемблер, потому что написан был не для этого. Он просто берет голый файл на NASM (обязательно) и выдает 64-битный ELF из этого единственного файла. Если вам необходимо что-то прилинковать к ассемблеру, то увы, придется собирать проект вручную или менять этот makefile
+

03-asm-bios/task2.asm

@@ -0,0 +1,81 @@
+global _start
+
+%define STDIN   0
+%define STDOUT  1
+%define STDERR  2
+
+section .data
+  src db 1, 2, 3, 4, 5, 6, 7, 8, 9, 0
+  src_size equ $-src
+
+  ; резервируем 1 килобайт для буффера ввода и вывода
+  ; также в отдельной переменной сохраняем размер этого буфера
+  print_buf: times 1024 db 0
+  buf_size equ $-print_buf
+
+section .text
+
+%macro DIGIT_TO_ASCII 1 ; макрос, принимающий один регистр
+  add %1, '0'
+%endmacro
+
+%macro PUSH_M 1-* ; push many; пушит в порядке следования
+  %rep %0
+  push %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro POP_M 1-* ; pop many. читает в порядке следования
+  %rep %0
+  pop %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro RPOP_M 1-* ; pop many. читает в обратном порядке
+  %rotate -1
+  %rep %0
+  pop %1
+  %rotate -1
+  %endrep
+%endmacro
+
+; Передачу аргументов будем делать при помощи ABI - стандартная практика для linux
+; Аргументы передаются в следующем порядке: rdi, rsi, rdx, rcx, r8, r9. Все, что не влезло, пушится в стек
+; У передачи через стек тоже есть особенности, но их мы пока касаться не будем
+
+print_from_buf: ; word -> void
+
+  PUSH_M rax, rsi, rdx, rdi ; сохраним регистры, которые точно попортим
+  mov rdx, rdi ; сколько выводить, в rdi содержится единственный аргумент
+  mov rsi, print_buf ; откуда выводить. Адрес буфера
+  mov rdi, STDOUT; куда выводить. Дескриптор файла. В нашем случае стандартного вывода
+  mov rax, 1
+  syscall
+
+  RPOP_M rax, rsi, rdx, rdi ; вернем значения регистров
+  ret
+
+_start:
+  mov rcx, src_size
+  mov rsi, src
+  mov rdi, print_buf
+  
+  xor rax, rax ; обнуляем регистр
+  .transfer: ; в цикле передаем данные, попутно конвертируя их в ascii
+  lodsb
+  DIGIT_TO_ASCII rax
+  stosb 
+  loop .transfer
+
+  mov [rdi + 1], BYTE `\n` ; Чтобы система не ругалась на отсутствие переноса
+
+  mov rdi, src_size
+  call print_from_buf
+
+exit:
+  mov rax, 60
+  mov rdi, 0
+  syscall
+

03-asm-bios/task4.asm

@@ -0,0 +1,219 @@
+global _start
+
+%define STDIN   0
+%define STDOUT  1
+%define STDERR  2
+
+section .data
+
+  ; резервируем 1 килобайт для буффера ввода и вывода
+  ; также в отдельной переменной сохраняем размер этого буфера
+  print_buf: times 1024 db 0
+  buf_size equ $-print_buf
+
+  input_buf: times 1024 db 0 ; буфер, в который будут читаться символы со стандартного ввода
+  input_size equ $-input_buf
+
+  array: times 512 dq 0 ; молимся, чтобы никому не пришло в голову писать так много
+  arr_size equ $-array
+
+  ; Для poll
+  %define POLLIN 0x001 ; Есть ли что почитать с буфера ввода. Понадобится для продолжения ввода
+  input_pollfd: dd STDIN
+                dw POLLIN
+  revents:      dw 0 ; возвращаемые события
+
+section .text
+
+%macro DIGIT_TO_ASCII 1 ; макрос, принимающий один аргумент (регистр или память)
+  add %1, '0'
+%endmacro
+
+%macro ASCII_TO_DIGIT 1 ; макрос, принимающий один аргумент (регистр или память)
+  sub %1, '0'
+%endmacro
+
+%macro PUSH_M 1-* ; push many; пушит в порядке следования
+  %rep %0
+  push %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro POP_M 1-* ; pop many. читает в порядке следования
+  %rep %0
+  pop %1
+  %rotate 1
+  %endrep
+%endmacro
+
+%macro RPOP_M 1-* ; pop many. читает в обратном порядке
+  %rotate -1
+  %rep %0
+  pop %1
+  %rotate -1
+  %endrep
+%endmacro
+
+%macro PUSHR8 1; закинуть восьмибитный регистр в стек
+  dec rsp
+  mov [rsp], %1
+%endmacro
+
+; Передачу аргументов будем делать при помощи ABI - стандартная практика для linux
+; Аргументы передаются в следующем порядке: rdi, rsi, rdx, rcx, r8, r9. Все, что не влезло, пушится в стек
+; У передачи через стек тоже есть особенности, но их мы пока касаться не будем
+
+clean_print_buf: ; none -> void
+  PUSH_M rax, rcx, rdi
+  mov rcx, buf_size
+  mov rdi, print_buf
+  xor rax, rax ; будем заносить нули во всю память
+  rep stosb
+  RPOP_M rax, rcx, rdi
+  ret
+
+print_from_buf: ; qword -> void; пытается вывести данные из буфера. аргумент не может быть больше 1024
+  PUSH_M rax, rsi, rdx, rdi ; сохраним регистры, которые точно попортим
+  mov rdx, rdi ; сколько выводить, в rdi содержится единственный аргумент
+  mov rsi, print_buf ; откуда выводить. Адрес буфера
+  mov rdi, STDOUT; куда выводить. Дескриптор файла. В нашем случае стандартного вывода
+  mov rax, 1
+  push rcx
+  syscall
+  pop rcx
+  RPOP_M rax, rsi, rdx, rdi ; вернем значения регистров
+  ret
+
+read_to_buf: ; none -> void. Пытается заполнить буфер из стандартного ввода
+  PUSH_M rdi, rsi, rdx
+  mov rdi, STDIN ; откуда читать (дескриптор файла)
+  mov rsi, input_buf ; куда читать
+  mov rdx, input_size ; Сколько пытаемся читать
+  mov rax, 0 ; системный вызов чтения
+  syscall
+  RPOP_M rdi, rsi, rdx ; rax содержит количество прочитанных байт, а это важно
+  ret
+
+poll_stdin:
+  PUSH_M rdi, rsi, rdx
+  mov rsi, 1 ; следим только за одним потоком
+  mov rax, 7 ; poll syscall
+  mov rdi, input_pollfd
+  mov rsi, 1 ; одна структура данных (изначально просто вызов принимает кучу таких)
+  mov rdx, 0 ; не ждать
+  syscall
+  RPOP_M rdi, rsi, rdx
+  ret
+
+print_number: ; qword (rdi) -> void
+  ; наша задача - сформировать массив символов.
+  ; Ну а раз мы не знаем точно сколько их будет, формировать его будем прямо в стеке. нам повезло, что он растет вниз
+  ; Нам очень повезло, что он растет вниз
+  ; создадим 2 локальные переменные - одну для размера массива, другую для делителя
+  push rbp
+  PUSH_M rdx, rdi, rsi ; сохранять регистры обязательно надо до того, как писать в стек символы
+  ; создаем базу для адресации. Тогда первая будет на rbp - 8 - делитель, а вторая на rbp - 16 - количество
+  mov rbp, rsp
+  ; [WARNING] тут надо будет сохранить регистры
+  push rsp ; сохраню, потому что после всей вакханалии я концов не сыщу
+  sub rsp, 16 ; выделяем место под 3 переменные
+  mov qword [rbp - 16], 10 ; пусть и жирно, но операнд обязан быть 64 разрядным для корректного деления
+  mov qword [rbp - 24], 0 ; счетчик
+  mov rax, rdi
+  push byte 0 ; при выводе он ориентируется на это как на конец строки
+  .division_loop:
+  xor rdx, rdx ; обнулим найденый остаток. (он просто еще и при делении принимает участие)
+  div qword [rbp - 16]
+  DIGIT_TO_ASCII dl
+  PUSHR8 dl ; поскольку в процессор не завезли возможность закинуть в стек 8 битный регистр, я им немного помог макросами
+  inc qword [rbp - 24] ; увеличиваем счетчик на единицу
+  test rax, rax ; делает and поразрядное с самим собой. Меня интересует, лежит ли в rax ноль
+  jnz .division_loop ; если в rax не ноль, то продолжаем цикл
+  ; выводим число
+  mov rax, 1
+  mov rdi, STDOUT
+  mov rsi, rsp
+  mov rdx, [rbp-24] ; уже не надо очищать, потому что в конце я просто восстановлю как было
+  push rcx
+  syscall
+  pop rcx
+
+  mov rsp, [rbp - 8]
+  RPOP_M rdx, rdi, rsi
+  pop rbp
+  ret
+
+_start:
+  mov rbp, rsp
+  ; Создадим 2 локальные переменные для аккумулятора размером 8 байт и для математических нужд 8 байт.
+  ; аккумулятор будет по адресу rbp - 8, а временная по rbp - 16
+  sub rsp, 16 
+  ; потом я не удержался и завел еще одну переменную - сколько мы успели написать в массив
+  sub rsp, 2 ; массив все равно размером всего 512, делать переменную больше нет смысла. rbp - 18
+
+  mov rsi, input_buf
+  mov rdi, array
+  .read_loop:
+  call read_to_buf ; системный вызов read вернет количество прочитаных байтов
+  mov rcx, rax ; сколько байтов прочиталось, столько и обработаем
+  ; обработаем информацию
+  xor rax, rax ; обнулим на всякий пожарный
+  jmp .read_byte
+
+  .separator_occured:
+  dec rcx
+  mov rax, [rbp - 8]
+  stosq
+  xor rax, rax
+  inc word [rbp - 18]
+  mov qword [rbp - 8], 0
+  test rcx, rcx
+  jz .check_buf
+  
+  .read_byte: ; цикл чтения
+  lodsb
+  ; проверим, цифра ли это. Если нет, то записываем в память то, что хранилось в локальной переменной
+  cmp al, '0'
+  jl .separator_occured
+  cmp al, '9'
+  jg .separator_occured
+
+  ASCII_TO_DIGIT al ; Если цифра, то конвертируем ее из ascii
+  ; Поскольку умножение и деление можно сделать только через регистр, придется извратиться
+  PUSH_M rax, rdx
+  mov rax, [rbp - 8]
+  mov qword [rbp - 16], 10
+  mul qword [rbp - 16]
+  mov [rbp - 8], rax
+  RPOP_M rax, rdx
+  add [rbp - 8], rax ; результат деления запишем в локальную переменную
+  loop .read_byte ; читаем буфер ввода до конца
+
+  .check_buf:
+  call poll_stdin
+  test dword [revents], POLLIN
+  jnz .read_loop
+
+  ; Теперь выведем прочитанный массив на экран
+  xor rcx, rcx
+  mov cx, [rbp - 18]
+  mov rsi, array
+  call clean_print_buf
+  .output_loop:
+  lodsq
+  mov rdi, rax
+  call print_number
+  mov byte [print_buf], ' '
+  mov rdi, 1
+  call print_from_buf ;  печатаем ровно 1 пробел
+  loop .output_loop
+  mov byte [print_buf], `\n`
+  mov rdi, 1
+  call print_from_buf
+
+exit:
+  mov rax, 60
+  mov rdi, 0
+  syscall
+

05-subroutines-params/README.md

@@ -2,5 +2,3 @@
 
 ## Подпрограммы и передача параметров
 
-Я делаю вариант 7, потому что так сказали купики
-

05-subroutines-params/task.asm

@@ -1,111 +0,0 @@
-global task_regs
-global task_stack
-global task_stack_wrapper
-
-section .note.GNU-stack
-
-section .text
-task_regs: ; rdi - указатель первое на число, rsi - указатель второе на число, rdx - результат
-  push rax
-  mov rax, [rdi]
-  mov [rdx], rax
-  mov rax, [rdi + 8]
-  mov [rdx + 8], rax
-  mov rax, [rsi + 8]
-  add [rdx + 8], rax
-  mov rax, [rsi]
-  adc [rdx], rax
-  pop rax
-  ret
-
-task_stack_wrapper: ;rdi - указатель, rsi - сколько
-  push rbp
-  mov rbp, rsp
-  push rdi
-  push rsi
-  shr rsi, 3 ; делим на 8 в ускоренном порядке. (приводим к байтам)
-  ; вычитаем 2 раза так как поверьте, циклы городить намного труднее
-  sub rsp, rsi
-  sub rsp, rsi
-  sub rsp, rsi
-  sub rsp, rsi
-  ; сыграем в чихарду
-  mov rcx, rsi
-  shl rcx, 2 ; сносим 2 числа, поэтому байтов в 2 раза больше + по 2 числа на число
-  mov rsi, rdi
-  mov rdi, rsp
-  rep movsb
-  ; закинем байт разрядности
-  ;push si
-  ;shl word [rsp], 8
-  dec rsp
-  mov al, [rbp - 16]
-  mov [rsp], al
-  ;add rsp, 1
-  ; вызов
-  call task_stack
-  ; восстанавливаемся
-  add rsp, 1 ; pачищаем разрядность
-  ; Циклы, как я уже и говорил, я делать отказываюсь
-  mov rcx, [rbp - 16]
-  shr rcx, 1 ; делим на 8 умножаем на 4, того множим на 2
-  add rsp, rcx ; затираем бедный стек
-  pop rsi
-  pop rdi
-  pop rbp
-  ret
-  
-task_stack: ; разрядность - 1 байт. Дальше читаем сколько надо. Читает в 2 раза больше разрядности
-  push rbp
-  mov rbp, rsp
-  mov al, [rbp + 16]
-  test al, 64
-  jnz .64bit
-  test al, 32
-  jnz .32bit
-  test al, 16
-  jnz .16bit
-  test al, 8
-  .8bit:
-  xor rax, rax
-  mov al, [rbp + 17]
-  mov ah, [rbp + 18]
-  mov cl, [rbp + 19]
-  mov ch, [rbp + 20]
-  add al, cl
-  adc ah, ch
-  jmp .end
-  .16bit:
-  xor rax, rax
-  mov ax, [rbp + 23] ; старшая
-  mov dx, [rbp + 21] ; младшая
-  mov cx, [rbp + 17] ; младшая
-  mov bx, [rbp + 19] ; старшая
-  ;add cx, bx
-  ;adc ax, dx
-  add dx, cx
-  adc ax, bx
-  pushfq ; Сохраним флаги на всякий
-  sal eax, 16
-  mov ax, dx
-  popfq
-  jmp .end
-  .32bit:
-  xor rax, rax
-  ; Не выровнянные данные - vae soli, но тут уже оставлю talis qualis, мне влом
-  mov eax, [rbp + 21] ; старшая часть 1-го
-  mov edx, [rbp + 29] ; старшая часть 2-го
-  mov ecx, [rbp + 17] ; младшая
-  mov ebx, [rbp + 25] ;младшая
-  add ecx, ebx
-  adc eax, edx
-  pushfq ; Сохраним флаги на всякий
-  sal rax, 32
-  mov eax, ecx
-  popfq
-  jmp .end
-  .64bit:
-  ;crush
-  .end:
-  pop rbp
-  ret

05-subroutines-params/task1.c

@@ -1,28 +0,0 @@
-#include <stdio.h>
-
-typedef struct
-{
-  unsigned long h;
-  unsigned long l;
-} LongNum;
-
-typedef unsigned char byte;
-
-extern void task_regs(LongNum* a, LongNum* b, LongNum* result);
-
-extern unsigned long task_stack(); // Для передачи через Си потребуется функцкия-обертка
-extern unsigned long task_stack_wrapper(void* nums, byte bits);
-
-int main()
-{
-  LongNum a = { 0x00000000, 0x01000000}; // По факту передача через стек)
-  LongNum b = { 0x10100010, 0x0900000f};
-  LongNum c;
-
-  task_regs(&a, &b, &c);
-  printf("new big num is %lx %lx\n", c.h, c.l); // Проверим, что сложили +- корректно
-  short int nums[4] = {88, 0, 11, 0}; // Порядок такой в демонстрационных целях
-  unsigned long new = task_stack_wrapper(nums, (sizeof(short int) * 8)); // Тут я лишь иммитирую что числа не влезают. По факту же все отлично лезет
-  printf("stacked number is %lu and should be 99\n", new);
-  return 0;
-}