section .bss

bufferPtr:          resb 8;                         pointer to buffer
freeSemaphore:      resb 8;                         free slots of buffer
usedSemaphore:      resb 8;                         used slots of buffer
bufferSize:         resb 8;                         buffer size
portion:            resb 8;                         portion-buffer for produce

section .rodata

maxBufferSize:  dd 0x7FFFFFFF;                      2^{31} - 1

section .text

global init
global producer
global consumer

extern produce
extern consume
extern malloc

extern proberen;
extern verhogen;

;helper labels (first 3 weren't combined in one because it adds non-sense complexity)

_returnMinusOne:
    mov rax, -1;                                    set return value to -1
    ret;                                            return -1

_returnMinusTwo:
    mov rax, -2;                                    set return value to -2
    ret;                                            return -2

_returnMinusThree:
    mov rax, -3;                                    set return value to -3
    ret;                                            return -3

_return:
    ret;                                            return

; main labels

init:
    mov qword [bufferSize], rdi;                     set value to N
    mov dword [freeSemaphore], edi;                  set initial value to N
    mov dword [usedSemaphore], 0;                    set initial value to 0

    cmp qword [bufferSize], maxBufferSize;           comparison beetween N and 2^{31} - 1
    ja _returnMinusOne;                              if greater return -1

    cmp qword [bufferSize], 0;                       comparison with zero
    je _returnMinusTwo;                              if zero return -2

    mov rdi, qword [bufferSize];                     set parameter for malloc
    imul rdi, 8;                                     multiply by 8
    call malloc;

    mov qword [bufferPtr], rax;                      set malloc's return value to bufferPtr
    cmp qword [bufferPtr], 0;                        check if null
    je _returnMinusThree;                            return -3 if null
    xor rax, rax;                                    overwise, return 0
    ret;


producer:
    xor r8, r8;                                     buffer slot number  (k)
    xor r9, r9;                                     portion             (p)

_producerLoop:
    mov rdi, portion;                               set fst parameter as &portion
    call produce;                                   produce(&portion)
    mov r9, [rdi];                                  assing produced value to p
    cmp eax, 0;                                     check if I should continue
    je _return;                                     in not, return

    mov edi, freeSemaphore;                         if ok, set fst parameter as &"free"
    call proberen;                                  P(free)

    mov rdi, [bufferPtr];
    mov [rdi + 8*r8], r9;                           copy value of produce

    mov edi, usedSemaphore;                         set fst parameter as &"used"
    call verhogen;                                  V(used)
_producerModulo:
    mov rcx, rbx;
    xor rdx, rdx;                                   clear rdx
    mov rax, r8;                                    numerator = k
    mov rbx, [bufferSize];                          denominator = N
    inc rax;                                        k++
    div rbx;                                        rdx:rax = (k + 1)%N:(k + )/N
    mov r8, rdx;                                    k = (k + 1)%N
    mov rbx, rcx;

    jmp _producerLoop;                              repeat


consumer:
    xor r8, r8;                                     buffer slot number  (k := r8)
    xor r9, r9;                                     portion             (p := r9)

_consumerLoop:
    mov edi, usedSemaphore;                         set fst parameter as &"used"
    call proberen;                                  P(used)

    mov rdi, [bufferPtr];
    mov r9, [rdi + 8*r8];                           p = buffer[k]

    mov edi, freeSemaphore;                         set fst parameter as &"free"
    call verhogen;                                  V(free)

_consumerModulo:
    mov rcx, rbx
    xor rdx, rdx;                                   clear rdx
    mov rax, r8;                                    numerator = k
    mov rbx, [bufferSize];                          denominator = N
    inc rax;                                        k++
    div rbx;                                        rdx:rax = (k + 1)%N:(k + )/N
    mov r8, rdx;                                    k = (k + 1)%N
    mov rbx, rcx;

    mov rdi, r9;                                    set fst parameter as "p"
    call consume;                                   consume(p)

    cmp eax, 0;
    je _return;

    jmp _consumerLoop;                              repeat