title: Sorting array in x86 assembly language
body: <p>I have to sort an array in descending order using parameters on the stack to an array and an array size.  I passed the size by value at <code>ebp+12</code> and the array by reference at <code>ebp+8</code>.</p>
  
  <p>I know the code is kind of all over the place, but I'm just trying to get to something that works and I can try to clean it up from there.  </p>
  
  <p>I've been debugging and it seems to iterate through as I want it to, but my array isn't being sorted.  I've been banging my head against this for hours, so any guidance would be greatly appreciated.  </p>
  
  <p>The pseudo-code algorithm I'm trying to follow is:</p>
  
  <pre><code>for(k=0, k&lt;arrlength-1,k++)
      I=K
      for(J=k+1,J&lt;arrlength,J++)
        if(arr[j]&gt;arr[i])
        I=J
      xchg(arr[k], arr[i])
  </code></pre>
  
  <p>And this is my attempt to implement it in x86 assembly:</p>
  
  <pre><code>;------------------------------------------------
  sortlist PROC
  ;Sorts an array of specified size into descending order
  ;Receives: DWORD request value, address of an array
  ;Returns: array of size request, sorted in descending order
  ;------------------------------------------------
  .data
  first   DWORD   ?
  next    DWORD   ?
  .code
  push    ebp
  mov     ebp, esp
  mov     ecx, [ebp+12]
  mov     edi, [ebp+8]
  mov     eax, 0
  mov     ebx, 0
  mov     edx, 0
  mov     esi, 0
  
  dec     ecx     ;loop for array length - 1
  L1:
      add     edi, ebx              ;ebx = 0 first loop, 4 all remaining loops
      mov     eax, [edi]            ;get the value of the first element
      mov     first, edi            ;store address of first element in first
      mov     next, edi             
  push    ecx
  push    edi
  L2:
      add     edi, 4            ;move to next element in array
      mov     edx, [edi]        ;set value of next element to edx
      cmp     [next], edx       ;compare element to next element
      jg      nxt        
      mov     next, edi         ;If less than, move address of greater to next
  nxt:    
      loop    L2
  
      mov     eax,[next]        ;move values pointed to by 1st &amp; next to regs
      mov     ebx,[first]
      mov     [first],eax       ;move values(swapped) to addresses
      mov     [next],ebx
  
      mov     ebx,4
      pop     edi
      pop     ecx
      loop    L1
  pop     ebp
  ret     8
  sortlist ENDP
  </code></pre>