# -------------------------------------------------------------
# Ma ona zwr ́oci ́c indeks dla najwiekszego z po ́sr ́od podanych
# argument ́ow. Dodatkowo, jez ̇eli maksymalan warto ́s ́c sie
# powtarza, funkcja ma zwr ́oci ́c 0.
# -------------------------------------------------------------
# int max_ind_asm(int a, int b, int c, int d);
#--------------------------------------------------------------
# gcc -m32 -Wall -Wextra test32.c bit32.s
#--------------------------------------------------------------
# rdi, rsi, rdx, rcx, r8, r9
#--------------------------------------------------------------

#64-bit register | Lower 32 bits | Lower 16 bits | Lower 8 bits
#==============================================================
#rax             | eax           | ax            | al
#rbx             | ebx           | bx            | bl
#rcx             | ecx           | cx            | cl
#rdx             | edx           | dx            | dl
#rsi             | esi           | si            | sil
#rdi             | edi           | di            | dil
#rbp             | ebp           | bp            | bpl
#rsp             | esp           | sp            | spl
#r8              | r8d           | r8w           | r8b
#r9              | r9d           | r9w           | r9b
#r10             | r10d          | r10w          | r10b
#r11             | r11d          | r11w          | r11b
#r12             | r12d          | r12w          | r12b
#r13             | r13d          | r13w          | r13b
#r14             | r14d          | r14w          | r14b
#r15             | r15d          | r15w          | r15b

# -------------------------------------------------------------

.text
.type max_ind_asm, @function
.global max_ind_asm

max_ind_asm:
  #przenosimy argumenty do rejestrow ze stosu; int-y wiec co 4
  movl  16(%esp), %edi    # zcwarty d
  movl  12(%esp), %esi    # trzeci c
  movl  8(%esp), %edx     # drugi b
  movl  4(%esp), %ebx     # pierwszy a

  movl  $1, %eax          # na razie do wyniku zakladamy ze pierwszy element to maks
  movl  %ebx, %ecx        # w %ecx bedziemy trzymac maksimum

  cmpl  %ecx, %edx        #sprawdzamy czy drugi wiekszy niz pierwszy (na razie maks)
  jg    second_greater    #jak wiekszy to skaczemy
  jmp   check_third       # jak nie wiekszy to sprawdzimy trzeci sobie

second_greater:
  movl  $2, %eax          # teraz drugi element najwiekszy to zwrocimy ten indeks
  movl  %edx, %ecx        # i uaktualniamy maksymalna

check_third:
  cmpl  %ecx, %esi        # porownujemy trzeci arg z maksem
  jg    third_greater
  jmp   check_fourth

third_greater: #analogicznie
  movl  $3, %eax
  movl  %esi, %ecx

check_fourth:
  cmpl  %ecx, %edi        # porownujemy czwarty arg z maksem
  jg    fourth_greater
  jmp   check_many        # skaczemy do sprawdzenia czy jest tylko jeden maks

fourth_greater:
  movl  $4, %eax          #czwarty indeks najwiekszy
  movl  %edi, %ecx        #przenosimy d do ecx

check_many:
  cmpl  $1, %eax
  je    check_without_first #sprawdzamy czy taki sam jest gdzies wartosc oprocz w pierwszym
  cmpl  $2, %eax
  je    check_without_second #te analogicznie
  cmpl  $3, %eax
  je    check_without_third
  cmpl  $4, %eax
  je    check_without_fourth
  jmp   return_to_c

check_without_first:
  cmpl  %edi, %ecx
  je    return_zero
  cmpl  %esi, %ecx
  je    return_zero
  cmpl  %edx, %ecx
  je    return_zero
  jmp   return_to_c

check_without_second:
  cmpl  %edi, %ecx
  je    return_zero
  cmpl  %esi, %ecx
  je    return_zero
  cmpl  %ebx, %ecx
  je    return_zero
  jmp   return_to_c

check_without_third:
  cmpl  %edi, %ecx
  je    return_zero
  cmpl  %ebx, %ecx
  je    return_zero
  cmpl  %edx, %ecx
  je    return_zero
  jmp   return_to_c

check_without_fourth:
  cmpl  %ebx, %ecx
  je    return_zero
  cmpl  %esi, %ecx
  je    return_zero
  cmpl  %edx, %ecx
  je    return_zero
  jmp   return_to_c

return_zero:
  movl  $0, %eax

return_to_c:
  ret