RandallHyde.com

Code: Select all

CODE: SELECT ALL
; Merge two 16-bit strings into a single 32-bit string.
; AX - Source for even numbered bits.
; BX - Source for odd numbered bits.
; CL - Scratch register.
; EDX- Destination register.

          mov cl, 16 
MergeLp:  shrd edx, eax, 1     ; Shift a bit from EAX into EDX. 
          shrd edx, ebx, 1     ; Shift a bit from EBX into EDX.
          shr  eax, 1
          shr  ebx, 1 
          dec  cl 
          jne  MergeLp; 

Code: Select all

CODE: SELECT ALL
shrd edx, eax, 6
shrd edx, ebx, 5
shrd edx, eax, 6
shrd edx, ebx, 11
shrd edx, eax, 4

Code: Select all

CODE: SELECT ALL
shrd edx, eax, 6
shr  eax, 6
shrd edx, ebx, 5
shr  ebx, 5
shrd edx, eax, 6
shr  eax, 6
shrd edx, ebx, 11
shrd edx, eax, 4

Code: Select all

mov rbx, p
mov rax, [rbx]

Code: Select all

numElements = 20

theArray dword 1,10,2,9,3,8,4,7,5,6
dword 99, 7, 2, 88, 5, 77, 66, 44, 3, 55

Code: Select all

; Listing 5-15
;
; Recursive quicksort

        option  casemap:none

nl          =       10
numElements =       20


            .const
ttlStr      byte    "Listing 5-15", 0
fmtStr1     byte    "Data before sorting: ", nl, 0
fmtStr2     byte    "%d "   ;Use nl and 0 from fmtStr3
fmtStr3     byte    nl, 0
fmtStr4     byte    "Data after sorting: ", nl, 0

        
            .data
theArray    dword   1,10,2,9,3,8,4,7,5,6
            dword   99, 7, 2, 88, 5, 77, 66, 44, 3, 55
        
            .code
            externdef printf:proc
            
; Return program title to C++ program:

            public  getTitle
getTitle    proc
            lea     rax, ttlStr
            ret
getTitle    endp


; quicksort-
;
;  Sorts an array using the quicksort algorithm.
;
; Here's the algorithm in C, so you can follow along:
;
; void quicksort(int a[], int low, int high)
; {
;     int i,j,Middle;
;     if( low < high)
;     {
;         Middle = a[(low+high)/2];
;         i = low;
;         j = high;
;         do
;         {
;             while(a[i] <= Middle) i++;
;             while(a[j] > Middle) j--;
;             if( i <= j)
;             {
;                 swap(a[i],a[j]);
;                 i++;
;                 j--;
;             }
;         } while( i <= j );
;  
;         // recursively sort the two sub arrays
;
;         if( low < j ) quicksort(a,low,j-1);
;         if( i < high) quicksort(a,j+1,high);
;     }
; }
;
; Args:
;    RCX (_a):      Pointer to array to sort
;    RDX (_lowBnd): Index to low bound of array to sort
;    R8 (_highBnd): Index to high bound of array to sort    

_a          equ     [rbp+16]        ;Ptr to array
_lowBnd     equ     [rbp+24]        ;Low bounds of array
_highBnd    equ     [rbp+32]        ;High bounds of array

; Local variables (register save area)

saveR9      equ     [rbp+40]        ;Shadow storage for R9
saveRDI     equ     [rbp-8]
saveRSI     equ     [rbp-16]
saveRBX     equ     [rbp-24]
saveRAX     equ     [rbp-32]

; Within the procedure body, these registers
; have the following meaning:
;
; RCX: Pointer to base address of array to sort
; EDX: Lower bound of array (32-bit index).
; r8d: Higher bound of array (32-bit index).
;
; edi: index (i) into array.
; esi: index (j) into array.
; r9d: Middle element to compare against

quicksort   proc
            push    rbp
            mov     rbp, rsp
            sub     rsp, 32
                        
; This code doesn't mess with RCX. No
; need to save it. When it does  mess
; with RDX and R8, it saves those registers
; at that point.

; Preserve other registers we use:

            mov     saveRAX, rax
            mov     saveRBX, rbx
            mov     saveRSI, rsi
            mov     saveRDI, rdi
            mov     saveR9, r9
            
            mov     edi, edx        ;i=low
            mov     esi, r8d        ;j=high

; Compute a pivotal element by selecting the
; physical middle element of the array.
        
            lea     rax, [rdx+r8*1]   ; RAX=low+high
            shr     rax, 1            ; (low+high)/2
            mov     r9d, [rcx][rax*4] ;Middle = ary[(i+j)/2]
                    

; Repeat until the edi and esi indexes cross one
; another (edi works from the start towards the end
; of the array, esi works from the end towards the
; start of the array).

rptUntil:   cmp     edi, esi        ;while( i <= j)
            jnle    sortPartitions
        
; Scan from the start of the array forward
; looking for the first element greater or equal
; to the middle element).
            
            dec     edi     ;to counteract inc, below
while1:     inc     edi     ;i = i + 1
            cmp     [rcx][rdi*4], r9d ;While ary[i] < middle 
            jl      while1

; Scan from the end of the array backwards looking
; for the first element that is less than or equal
; to the middle element.

            inc     esi     ;To counteract dec, below
while2:     dec     esi     ;j = j - 1
            cmp     [rcx][rsi*4], r9d       ;while ary[j] < Middle
            jg      while2            
            
            
; If we've stopped before the two pointers have
; passed over one another, then we've got two
; elements that are out of order with respect
; to the middle element, so swap these two elements.
            
            cmp     edi, esi ;If i <= j
            jnle    sortPartitions            
           
            push    r9
            mov     eax, [rcx][rdi*4] ;Swap ary[i] and ary[j]
            mov     r9d, [rcx][rsi*4]
            mov     [rcx][rsi*4], eax
            mov     [rcx][rdi*4], r9d
            pop     r9
            
            inc     edi     ;i = i + 1
            dec     esi     ;j = j - 1
                
endif1:     cmp     edi, esi ;Until i > j
            jng     rptUntil
        
; We have just placed all elements in the array in
; their correct positions with respect to the middle
; element of the array. So all elements at indexes
; greater than the middle element are also numerically
; greater than this element. Likewise, elements at
; indexes less than the middle (pivotal) element are
; now less than that element. Unfortunately, the
; two halves of the array on either side of the pivotal
; element are not yet sorted. Call quicksort recursively
; to sort these two halves if they have more than one
; element in them (if they have zero or one elements, then
; they are already sorted).
        
sortPartitions:
            cmp     edx, esi ;if lowBnd < j
            jnl     endif2

            ; Note: a is still in RCX,
            ; Low is still in RDX
            ; Need to preserve R8 (High)
            ; Note: quicksort doesn't require stack alignment
                

            cmp     edx, esi        ;if( low < j ) 
            jnl     endif2

            push    rcx 
            push    r8
            mov     r8d, esi    
            call    quicksort ;( a, low, j )
            pop     r8
            pop     rcx
            
            ; Note: a is still in RCX,
            ; High is still in R8d
            ; Need to preserve RDX (low)
            ; Note: quicksort doesn't require stack alignment
              
;call printArray

endif2:     cmp     edi, r8d        ;if( i < high )
            jnl     endif3

            push    rcx
            push    rdx
            mov     edx, edi  
            call    quicksort ;( a, i, High )
            pop     rdx
            pop     rcx

; Restore registers and leave:
            
endif3:
            mov     rax, saveRAX 
            mov     rbx, saveRBX 
            mov     rsi, saveRSI 
            mov     rdi, saveRDI 
            mov     r9, saveR9
            leave
            ret  
quicksort   endp
    


; Little utility to print the array elements:

printArray  proc
            push    r15
            push    rbp
            mov     rbp, rsp
            sub     rsp, 40 ;Shadow parameters
            
            lea     r9, theArray
            mov     r15d, 0
whileLT10:  cmp     r15d, numElements
            jnl     endwhile1
            
            lea     rcx, fmtStr2
            lea     r9, theArray
            mov     edx, [r9][r15*4]
            call    printf
            
            inc     r15d
            jmp     whileLT10

endwhile1:  lea     rcx, fmtStr3
            call    printf
            leave
            pop     r15
            ret
printArray  endp

; Here is the "asmMain" function.

        
            public  asmMain
asmMain     proc
            push    rbp
            mov     rbp, rsp
            sub     rsp, 32   ;Shadow storage
        
; Display unsorted array:

            lea     rcx, fmtStr1
            call    printf
            call    printArray
            

; Sort the array

            lea     rcx, theArray
            xor     rdx, rdx                ;low = 0
            mov     r8d, numElements-1      ;high= 9
            call    quicksort ;(theArray, 0, 9)
            
; Display sorted results:

            lea     rcx, fmtStr4
            call    printf
            call    printArray   
            
            leave
            ret     ;Returns to caller
        
asmMain     endp
            end

Code: Select all

   mov rcx, Length  ; Compute (Length mod 8)
    and rcx, 111b    ; Execute movsb only if # of bytes/8 <> 0
    jz divisibleBy8  ; Copy the remaining 1 to 7 bytes
    rep movsb
divisibleBy8:

Code: Select all

lea eax, [eax][eax * 2] ; EAX = ECX * 3
lea eax, [eax * 4]      ; EAX = ECX * 4

Code: Select all

lea eax, [eax][eax * 2] ; EAX = EAX * 3
lea eax, [eax * 4]      ; EAX = EAX * 4

Code: Select all

mov eax, x
imul y ; Note: Sign-extends into EDX
idiv z
mov x, eax

Code: Select all

neg eax