обертка для закидывания аргументов в стек переписана на nasm

01-asm-basics/time.asm

@@ -1,67 +0,0 @@
-global main
-
-extern printf
-
-%define CLOCK_REALTIME 0
-
-; struct timespec { time_t tv_sec; long tv_nsec; }
-struc timespec
-  .tv_sec: resq 1
-  .tv_nsec: resq 1
-endstruc
-
-section .note.GNU-stack ; чтобы не жаловался линкер
-
-section .bss
-
-start: ; uses timespec model
-  times 2 resq 1
-
-finish:
-  times 2 resq 1
-
-section .data
-
-  fstring db "Operations took %ul seconds and %ul milliseconds", 10, 0
-  flen equ $-fstring
-
-section .text
-
-main: ; лично в моей системе time_t представляет из себя long int
-  mov rax, 228 ; Системный вызов получения времени
-  mov rdi, CLOCK_REALTIME
-  mov rsi, start
-  syscall
-
-  ; insert your code here
-  mov rcx, 20000
-
-  looper:
-  mov rax, start
-  loop looper
-
-  mov rax, 228
-  mov rdi, CLOCK_REALTIME
-  mov rsi, finish
-  syscall
-
-  ; считаем время для секунда и миллисекунд
-  ; секунды
-  mov rsi, [finish + timespec.tv_sec]
-  sub rsi, [start + timespec.tv_sec]
-
-  ; миллисекунды
-  mov rdx, [finish + timespec.tv_nsec]
-  sub rdx, [start + timespec.tv_nsec]
-
-  mov rdi, fstring
-  mov rax, 0
-  sub rsp, 8
-  call printf
-  add rsp, 8
-
-exit:
-  mov rax, 60
-  mov rdi, 0
-  syscall
-

03-asm-bios/Makefile

@@ -1,13 +0,0 @@
-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))

04-addr-methods/Makefile

@@ -1,24 +0,0 @@
-ASM = nasm
-CXX = gcc
-CXX_FLAGS = -Og -static
-ASM_FLAGS = -felf64 -g
-LINK = ld
-
-task3: task3_c.o task3.o
-	$(CXX) -Og $^ -o $@ -g
-
-task3_c.o: task3.c
-	$(CXX) -Og -c $^ -o $@ -g
-
-task2: task2.o
-	$(CXX) $(CXX_FLAGS) $^ -o $@
-
-%: %.o
-	$(LINK) -o $@ $^
-
-%.o: %.asm
-	$(ASM) $(ASM_FLAGS) $^ -o $@
-
-clean:
-	rm -f *.o
-	rm -f $(subst .asm, $(empty), $(wildcard *.asm))

04-addr-methods/README.md

@@ -1,4 +1,4 @@
 # Лабораторная работа 4
 
-На данный момент нормального README не будет, потому что у меня немного нет времени его офомить. Как только сдам лабу - напишу тут немного больше
+## Способы адресации и сегментная организация памяти
 

04-addr-methods/task1.asm

@@ -1,33 +0,0 @@
- global _start
-
- section .data
-
-  %macro FILL_ASC 1
-  %assign NUM 0
-  %rep %1
-  db NUM
-  %assign NUM NUM + 1
-  %endrep
-  %endmacro
-
-  example: FILL_ASC 256
-
- section .text
-
- _start:
-  ; В качестве базы возьму inc
-  ; регистровая
-  inc ecx
-  mov rax, example
-  ; косвенно-регистровая
-  inc byte [rax]
-  ; "Индексно-базовая", хотя у меня почти все может быть базой
-  inc byte [rax + rbx]
-  ; "Индексно-базовая" со смещением
-  inc byte [rax + rbx + 122]
-
-  ; Ну в целом... все
-  mov rax, 60
-  mov rdi, 0
-  syscall
-  

04-addr-methods/task2.asm

@@ -1,139 +0,0 @@
-global main
-
-extern printf
-
-struc timespec ; структура, в которой линукс хранит время. Тут нужна для удобства в будущем
-  .tv_sec: resq 1
-  .tv_nsec: resq 1
-endstruc
-
-%include "timer.inc"
-
-section .note.GNU-stack
-
-section .data
-  example: times 128 db 127
-
-section .bss
-  ; uses timespec model 
-  start:      resq 2
-  finish:     resq 2
-  deltatime:  resq 2
-
-section .text
-
-%macro PUSH_M 1-*
-  %rep %0
-  push %1
-  %rotate 1
-  %endrep
-%endmacro
-
-%macro RPOP_M 1-*
-  %rotate -1
-  %rep %0
-  pop %1
-  %rotate -1
-  %endrep
-%endmacro
-
-%define CLOCK_REALTIME 0
-%macro TIME_1_000_000 0-1+ ; принимает команду, которую будет пытаться обмерить по времени
-  PUSH_M rax, rdi, rsi, rcx
-  mov rax, 228 ; Время начала
-  mov rdi, CLOCK_REALTIME
-  mov rsi, start
-  syscall
-  RPOP_M rax, rdi, rsi, rcx
-
-  mov rcx, 10000000000; выполняем миллион раз
-  %%loop:
-  %1
-  loop %%loop
-
-  PUSH_M rax, rdi, rsi, rcx
-  mov rax, 228 ; Время конца
-  mov rdi, CLOCK_REALTIME
-  mov rsi, finish
-  syscall
-  RPOP_M rax, rdi, rsi, rcx
-  
-  ; считаем секунды
-  push rax ; можно было бы оптимизировать, но мне лень макросы переписывать
-  mov rax, [finish + timespec.tv_sec]
-  sub rax, [start + timespec.tv_sec]
-  mov [deltatime + timespec.tv_sec], rax
-
-  ; считаем наносекунды
-  mov rax, [finish + timespec.tv_nsec]
-  sub rax, [start + timespec.tv_nsec]
-  jns %%save_result
-  dec qword [deltatime + timespec.tv_sec] ; занимаем миллиард наносекунд
-  add rax, 1000000000 ; прибавляем занятый разряд
-  %%save_result:
-  mov [deltatime + timespec.tv_nsec], rax
-  pop rax
-%endmacro
-
-%macro PRINT_DELTATIME 1
-  ;sub rsp, 8
-  mov rdi, str_template
-  mov rsi, %1
-  mov rdx, [deltatime + timespec.tv_sec]
-  mov rcx, [deltatime + timespec.tv_nsec]
-  call printf
-  ;add rsp, 8
-%endmacro
-
-main:
-  push rbp
-  mov rbp, rsp
-  sub rsp, 16
-  xor rax, rax ; поскольку приходим сюда из компилятора, лучше обнулить
-  TIME_1_000_000 
-  PRINT_DELTATIME nop_command
-
-  TIME_1_000_000 inc rax
-  PRINT_DELTATIME reg_command
-
-  mov rax, example
-  TIME_1_000_000 inc byte [rax]
-  PRINT_DELTATIME rel_reg
-
-  mov rax, example
-  xor rbx, rbx
-  TIME_1_000_000 inc byte [rax + rbx]
-  PRINT_DELTATIME ind_base
-
-  mov rax, example
-  xor rbx, rbx
-  TIME_1_000_000 inc byte [rax + rbx + 122]
-  PRINT_DELTATIME ind_base_disp
-
-  ; Под конец давайте посчитаем тактовую частоту на примере той же самой команды
-  rdtsc
-  mov [rbp - 4], edx
-  mov [rbp - 8], eax
-  mov rcx, 10000000000
-  mov rax, example
-  xor rbx, rbx
-  .loop:
-  inc byte [rax + rbx + 122]
-  loop .loop
-  rdtsc
-  sub eax, [rbp - 8]
-  sbb edx, [rbp - 4]
-  mov [rbp - 8], eax
-  mov [rbp - 4], edx
-  
-  mov [rbp - 16], rsp
-  and rsp, -16
-  mov rdi, tick_count
-  mov rsi, [rbp - 8]
-  call printf
-
-  mov rsp, rbp
-  pop rbp
-  xor rax, rax ; сообщаем gcc, что все закончилось успешно
-  ret
-

04-addr-methods/task3.asm

@@ -1,96 +0,0 @@
-global fill_arr1
-global fill_arr2
-
-section .note.GNU-stack
-
-section .text
-
-%macro PUSH_M 1-*
-  %rep %0
-  push %1
-  %rotate 1
-  %endrep
-%endmacro
-
-%macro RPOP_M 1-*
-  %rotate -1
-  %rep %0
-  pop %1
-  %rotate -1
-  %endrep
-%endmacro
-
-fill_arr1:
-  push rbp
-  mov rbp, rsp
-  PUSH_M rdi, rsi, rdx
-  ; Вычисляем сколько числе в строке
-  mov rax, [rbp - 16]
-  xor rdx, rdx
-  div qword [rbp - 24]
-  push rax ; сохраняем в локальные переменные. rbp - 32
-  ; Вычисляем сколько проходов цикла необходимо
-  mov rax, [rbp - 24]
-  xor rdx, rdx
-  mov rcx, 2
-  div rcx
-  push rax ; rbp-40
-
-  ; Надеюсь rdi не успел поменяться
-  ; заполняем память
-  push rbx
-  mov rbx, [rbp - 32]
-  mov rcx, [rbp - 40]
-  mov rax, 777 ; специально такое число, чтобы выделялось
-  .next_row:
-  push rcx
-  mov rcx, [rbp - 32]
-  rep stosd
-  lea rdi, [rdi + 4 * rbx] ; пропускаем строку
-  pop rcx
-  loop .next_row
-  pop rbx
-
-  add rsp, 16 ; чистим 2 доп переменные, образовавшиеся в процессе вычислений
-  RPOP_M rdi, rsi, rdx
-  pop rbp
-  ret
-
-fill_arr2:
-  push rbp
-  mov rbp, rsp
-  PUSH_M rdi, rsi, rdx
-  ; Вычисляем сколько числе в строке
-  mov rax, [rbp - 16]
-  xor rdx, rdx
-  div qword [rbp - 24]
-  push rax ; сохраняем в локальные переменные. rbp - 32
-  ; Вычисляем сколько проходов цикла необходимо
-  mov rax, [rbp - 24]
-  xor rdx, rdx
-  mov rcx, 2
-  div rcx
-  push rax ; rbp-40
-
-  ; Надеюсь rdi не успел поменяться
-  ; заполняем память
-  push rbx
-  mov rbx, [rbp - 32]
-  mov rcx, [rbp - 40]
-  mov rax, 777 ; специально такое число, чтобы выделялось
-  .next_row:
-  push rcx
-  mov rcx, [rbp - 32]
-  .fill:
-  mov [rdi], rax
-  lea rdi, [rdi + 4]
-  loop .fill
-  lea rdi, [rdi + 4 * rbx] ; пропускаем строку
-  pop rcx
-  loop .next_row
-  pop rbx
-
-  add rsp, 16 ; чистим 2 доп переменные, образовавшиеся в процессе вычислений
-  RPOP_M rdi, rsi, rdx
-  pop rbp
-  ret

04-addr-methods/task3.c

@@ -1,43 +0,0 @@
-#include <stdio.h>
-#include <time.h>
-
-extern void fill_arr1(int* arr, size_t size, size_t row_count);
-extern void fill_arr2(int* arr, size_t size, size_t row_count);
-
-double measure_fill_time(void(*function)(int*, size_t, size_t), int* arr, size_t size, size_t row_count)
-{
-  const size_t times = 10000000;
-  clock_t begin = clock();
-  for (size_t i = 0; i < times; i++)
-  {
-    function(arr, size, row_count);
-  }
-  clock_t end = clock();
-  return (double)(end - begin)/(CLOCKS_PER_SEC);
-}
-
-int main()
-{
-  const int arr_size = 256;
-  int array1[arr_size];
-
-  printf("String methods took %fs to loop 10,000,000 times\n", measure_fill_time(fill_arr1, array1, arr_size, 16));
-
-  for (size_t i = 0; i < arr_size; i++)
-  {
-    printf("%d ", array1[i]);
-  }
-  printf("\b \n");
-
-  int array2[arr_size];
-
-  printf("Lea methods took %fs on to loop 10,000,000 times\n", measure_fill_time(fill_arr2, array2, arr_size, 16));
-  for (size_t i = 0; i < arr_size; i++)
-  {
-    printf("%d ", array2[i]);
-  }
-  printf("\b \n");
-  
-  return 0;
-}
-

04-addr-methods/timer.inc

@@ -1,13 +0,0 @@
-
-section .data
-  str_template: db "Command %s took %lld seconds and %lld nanoseconds to execute 1 000 000 000 times", 10, 0
-  template_len equ $-str_template
-
-  nop_command:        db '`empty loop`', 0
-  reg_command:        db '`inc ebx`', 0
-  rel_reg:            db '`inc byte [rax]`', 0
-  ind_base:           db '`inc byte [rax + rbx]`', 0
-  ind_base_disp:      db '`inc byte [rax + rbx + 122]`', 0
-
-  tick_count:         db 'Last command also took %lli ticks to complete', 10, 0
-

05-subroutines-params/README.md

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

05-subroutines-params/task.asm

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,28 @@
+#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;
+}