Reversing an array in assembly

Question

I'm trying to figure out how to reverse an array in assembly in a way that makes it as flexible as possible. The code I have so far is this:

; This program takes an integer array and reverses it's elements, using a loop, the SIZE, TYPE and LENGTHOF
; operators.

TITLE lab4              (lab4.asm)

INCLUDE Irvine32.inc

.data

    arr DWORD 1h, 2h, 3h, 4h, 5h, 6h    ; Array of integers with 6 elements.
    len DWORD LENGTHOF arr / 2          ; The length of the array divided by 2.
    ;rng    DWORD LENGTHOF arr          ; The complete length of the array.

.code
main PROC

    mov eax, len    ; Moves the length (divided by 2) into the eax register.
    mov ebx, len    ; Sets the ebx register to 0 to serve as the counter.
    mov ecx, len    ; Loads the length of the array into the ecx register.
    mov edx, len    ; Sets a counter that starts at the end of the array.

    dec edx

    ; Start of the loop
    L1: 

    mov eax, arr[esi + (TYPE arr * ebx)]    ; Assigns to eax the value in the current beginning counter.

    xchg eax, arr[esi + (TYPE arr * edx) ]  ; Swaps the value in eax with the value at the end counter.

    mov arr[esi + (TYPE arr * ebx)], eax    ; Assigns the current beginning counter the value in eax.

    dec edx                 ; Decrements the end counter by 1.
    inc ebx                 ; Increments the beginning counter by 1.
    loop    L1              
    ; end of the loop

    mov ecx, LENGTHOF arr
    mov ebx, 0

    ; Start of loop
    L2:                                     ; Loop that runs through the array to check and make sure
    mov eax, arr[esi + (TYPE arr * ebx)]    ; the elements are reversed.
    inc     ebx
    call    DumpRegs
    loop    L2          
    ; End of loop

    exit
main ENDP

END main

This works, but only if the array has an even number of elements. What should I do to make it work for an odd number as well?

You can use the stack to reverse it: push all of it then pop it, it will be in reverse order ;) — m0skit0, Mar 01 '14 at 22:13
I'm not sure if the assignment would allow that. I have to use functions like SIZEOF, LENGTHOF, TYPE and that sort to do this. I have to basically swap them all by hand. — user1675108, Mar 01 '14 at 22:16
mov ebx,len doesn't match the comment which implies you have a mov ebx,0. It seems like the current code would just reverse the array twice, ending up back where you started. To avoid this after mov ecx,len , there should be a shr ecx,1. For odd length, the middle value is not swapped. — rcgldr, Mar 02 '14 at 01:02

score 3 · Answer 1 · answered Mar 02 '14 at 10:24

In general it's best to imagine it as 2 pointers. The first pointer begins at the start of the array and moves towards the end, and the second pointer begins at the end of the array and moves towards the start.

If there are an even number of items in the array, eventually start will be higher than end. If there are an odd number of items in the array, eventually start will be equal to end. Basically, in C you'd be looking for something like while(start < end) { ... }.

For assembly (NASM syntax), this might look a bit like this:

;Reverse array of 32-bit "things" (integers, pointers, whatever)
;
;Input
; esi = address of array
; ecx = number of entries in array

reverseArrayOf32bit:
    lea edi,[esi+ecx*4-4]      ;edi = address of last entry
    cmp esi,edi                ;Is it a tiny array (zero or 1 entry)?
    jnb .done                  ; yes, it's done aleady

.next:
    mov eax,[esi]              ;eax = value at start
    mov ebx,[edi]              ;ebx = value at end
    mov [edi],eax              ;Store value from start at end
    mov [esi],ebx              ;Store value from end at start

    add esi,4                  ;esi = address of next item at start
    sub edi,4                  ;edi = address of next item at end
    cmp esi,edi                ;Have we reached the middle?
    jb .next                   ; no, keep going

.done:
    ret

Reversing an array in assembly

1 Answers1

Linked