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

05-subroutines-params/README.md

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

05-subroutines-params/task.asm

@@ -1,10 +1,10 @@
 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]
@@ -17,11 +17,48 @@ task_regs: ; rdi - указатель первое на число, 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 + 8]
+  mov al, [rbp + 16]
   test al, 64
   jnz .64bit
   test al, 32
@@ -31,32 +68,35 @@ task_stack: ; разрядность - 1 байт. Дальше читаем с
   test al, 8
   .8bit:
   xor rax, rax
-  mov al, [rbp + 9]
+  mov al, [rbp + 17]
-  mov ah, [rbp + 10]
+  mov ah, [rbp + 18]
-  mov cl, [rbp + 11]
+  mov cl, [rbp + 19]
-  mov ch, [rbp + 12]
+  mov ch, [rbp + 20]
   add al, cl
   adc ah, ch
   jmp .end
   .16bit:
   xor rax, rax
-  mov ax, [rbp + 11] ; старшая часть 1-го
+  mov ax, [rbp + 23] ; старшая
-  mov dx, [rbp + 15] ; старшая часть 2-го
+  mov dx, [rbp + 21] ; младшая
-  mov cx, [rbp + 9] ; младшая
+  mov cx, [rbp + 17] ; младшая
-  mov bx, [rbp + 13] ;младшая
+  mov bx, [rbp + 19] ; старшая
-  add cx, bx
+  ;add cx, bx
-  adc ax, dx
+  ;adc ax, dx
+  add dx, cx
+  adc ax, bx
   pushfq ; Сохраним флаги на всякий
   sal eax, 16
-  mov ax, cx
+  mov ax, dx
   popfq
   jmp .end
   .32bit:
   xor rax, rax
-  mov eax, [rbp + 11] ; старшая часть 1-го
+  ; Не выровнянные данные - vae soli, но тут уже оставлю talis qualis, мне влом
-  mov edx, [rbp + 15] ; старшая часть 2-го
+  mov eax, [rbp + 21] ; старшая часть 1-го
-  mov ecx, [rbp + 9] ; младшая
+  mov edx, [rbp + 29] ; старшая часть 2-го
-  mov ebx, [rbp + 13] ;младшая
+  mov ecx, [rbp + 17] ; младшая
+  mov ebx, [rbp + 25] ;младшая
   add ecx, ebx
   adc eax, edx
   pushfq ; Сохраним флаги на всякий
@@ -67,4 +107,5 @@ task_stack: ; разрядность - 1 байт. Дальше читаем с
   .64bit:
   ;crush
   .end:
+  pop rbp
   ret

05-subroutines-params/task1.c

@@ -11,35 +11,7 @@ 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);
-unsigned long stack_wrapper(void* arr, byte bits)
-{
-  unsigned long result = 0;
-  byte shift = bits >> 3;
-  printf("shift is %d", shift);
-  __asm__(
-      "pushq %%rsp\n\t"
-      "movq $2, %%rcx\n\t"
-      "subq $2, %%rsp\n\t"
-      "movb %2, (%%rsp)\n\t"
-      "xorq %%rdx, %%rdx\n\t"
-      "pop %%dx\n\t"
-      "stack_push_loop:\n\t"
-      "subq %%rdx, %%rsp\n\t"
-      "movq (%1), %%rsp\n\t"
-      "addq %%rdx, %1\n\t"
-      "loopq stack_push_loop\n\t"
-      "call stack_wrapper\n\t"
-      "addq %%rdx, %%rdx\n\t" // умножаем на 2
-      "addq %%rdx, %%rsp\n\t"
-      "popq %%rsp"
-      :"=a"(result)
-      :"b"(arr), "d"(shift)
-      :"%rcx"
-  );
-  result = task_stack();
-  return result;
-}
 
 int main()
 {
@@ -48,8 +20,9 @@ int main()
   LongNum c;
 
   task_regs(&a, &b, &c);
-  printf("asdfasfasfasfda %lx %lx", c.h, c.l); // Проверим, что сложили +- корректно
+  printf("new big num is %lx %lx\n", c.h, c.l); // Проверим, что сложили +- корректно
-  int nums[2] = {88, 11};
+  short int nums[4] = {88, 0, 11, 0}; // Порядок такой в демонстрационных целях
-  stack_wrapper(nums, sizeof(int));
+  unsigned long new = task_stack_wrapper(nums, (sizeof(short int) * 8)); // Тут я лишь иммитирую что числа не влезают. По факту же все отлично лезет
+  printf("stacked number is %lu and should be 99\n", new);
   return 0;
 }