.DATA

    align 16t

rglongs DD 0,0,0,0,0,0,0,0
rgquads DQ 0,0,0,0,0,0,0,0


    .CODE

;;
;; test a24a - increment memory, risc-like code using INC by constant
;; 

    ECHO TEST A24a

_test_a24a PROC
    mov     ecx,cLOOPS*cINSTR

    align 16t

@la24a:
    mov     eax,dword ptr rglongs+0
    inc     eax
    mov     dword ptr rglongs+0,eax
    mov     eax,dword ptr rglongs+4
    inc     eax
    mov     dword ptr rglongs+4,eax
    mov     eax,dword ptr rgquads+0
    mov     edx,dword ptr rgquads+4
    add     eax,1
    adc     edx,0
    mov     dword ptr rgquads+0,eax
    mov     dword ptr rgquads+4,edx
    mov     eax,dword ptr rgquads+8
    mov     edx,dword ptr rgquads+12t
    add     eax,1
    adc     edx,0
    mov     dword ptr rgquads+8,eax
    mov     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24a

    ret
_test_a24a ENDP


;;
;; test a24b - increment memory, risc-like code using ADD by constant
;; 

    ECHO TEST A24b

_test_a24b PROC
    mov     ecx,cLOOPS*cINSTR

    align 16t

@la24b:
    mov     eax,dword ptr rglongs+0
    add     eax,1
    mov     dword ptr rglongs+0,eax
    mov     eax,dword ptr rglongs+4
    add     eax,1
    mov     dword ptr rglongs+4,eax
    mov     eax,dword ptr rgquads+0
    mov     edx,dword ptr rgquads+4
    add     eax,1
    adc     edx,0
    mov     dword ptr rgquads+0,eax
    mov     dword ptr rgquads+4,edx
    mov     eax,dword ptr rgquads+8
    mov     edx,dword ptr rgquads+12t
    add     eax,1
    adc     edx,0
    mov     dword ptr rgquads+8,eax
    mov     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24b

    ret
_test_a24b ENDP


;;
;; test a24c - increment memory, risc-like code using parallel ADD register
;; 

    ECHO TEST A24c

_test_a24c PROC
    mov     ecx,cLOOPS*cINSTR
    push    ebx
    push    ebp
    mov     ebx,1
    mov     edi,0

    align 16t

@la24c:
    mov     eax,dword ptr rglongs+0
    add     eax,ebx
    mov     dword ptr rglongs+0,eax
    mov     eax,dword ptr rglongs+4
    add     eax,ebx
    mov     dword ptr rglongs+4,eax
    mov     eax,dword ptr rgquads+0
    mov     edx,dword ptr rgquads+4
    add     eax,ebx
    adc     edx,ebp
    mov     dword ptr rgquads+0,eax
    mov     dword ptr rgquads+4,edx
    mov     eax,dword ptr rgquads+8
    mov     edx,dword ptr rgquads+12t
    add     eax,ebx
    adc     edx,ebp
    mov     dword ptr rgquads+8,eax
    mov     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24c

    pop     ebp
    pop     ebx
    ret
_test_a24c ENDP


;;
;; test a24d - increment memory, risc-like code using serial ADD register
;; 

    ECHO TEST A24d

_test_a24d PROC
    mov     ecx,cLOOPS*cINSTR
    push    ebx
    push    ebp
    mov     ebx,1
    mov     edi,0

    align 16t

@la24d:
    mov     eax,dword ptr rglongs+0
    add     eax,ebx
    mov     dword ptr rglongs+0,eax
    mov     eax,dword ptr rglongs+4
    add     eax,ebx
    mov     dword ptr rglongs+4,eax
    mov     eax,dword ptr rgquads+0
    add     eax,ebx
    mov     dword ptr rgquads+0,eax
    mov     eax,dword ptr rgquads+4
    adc     eax,ebp
    mov     dword ptr rgquads+4,eax
    mov     eax,dword ptr rgquads+8
    add     eax,ebx
    mov     dword ptr rgquads+8,eax
    mov     eax,dword ptr rgquads+12t
    adc     eax,ebp
    mov     dword ptr rgquads+12t,eax

    sub     ecx,1
    jne     @la24d

    pop     ebp
    pop     ebx
    ret
_test_a24d ENDP


;;
;; test a24e - increment indirect memory, risc-like code using parallel ADD reg
;; 

    ECHO TEST A24e

_test_a24e PROC
    mov     ecx,cLOOPS*cINSTR
    push    ebx
    push    ebp
    mov     ebx,1
    mov     edi,0
    push    esi
    push    edi
    lea     esi,rglongs
    lea     edi,rgquads

    align 16t

@la24e:
    mov     eax,dword ptr [esi+0]
    add     eax,ebx
    mov     dword ptr [esi+0],eax
    mov     eax,dword ptr [esi+4]
    add     eax,ebx
    mov     dword ptr [esi+4],eax
    mov     eax,dword ptr [edi+0]
    mov     edx,dword ptr [edi+4]
    add     eax,ebx
    adc     edx,ebp
    mov     dword ptr [edi+0],eax
    mov     dword ptr [edi+4],edx
    mov     eax,dword ptr [edi+8]
    mov     edx,dword ptr [edi+12t]
    add     eax,ebx
    adc     edx,ebp
    mov     dword ptr [edi+8],eax
    mov     dword ptr [edi+12t],edx

    sub     ecx,1
    jne     @la24e

    pop     edi
    pop     esi
    pop     ebp
    pop     ebx
    ret
_test_a24e ENDP


;;
;; test a24f - increment indirect memory, risc-like code using serial ADD reg
;; 

    ECHO TEST A24f

_test_a24f PROC
    mov     ecx,cLOOPS*cINSTR
    push    ebx
    push    ebp
    mov     ebx,1
    mov     edi,0
    push    esi
    push    edi
    lea     esi,rglongs
    lea     edi,rgquads

    align 16t

@la24f:
    mov     eax,dword ptr [esi+0]
    add     eax,ebx
    mov     dword ptr [esi+0],eax
    mov     eax,dword ptr [esi+4]
    add     eax,ebx
    mov     dword ptr [esi+4],eax
    mov     eax,dword ptr [edi+0]
    add     eax,ebx
    mov     dword ptr [edi+0],eax
    mov     eax,dword ptr [edi+4]
    adc     eax,ebp
    mov     dword ptr [edi+4],eax
    mov     eax,dword ptr [edi+8]
    add     eax,ebx
    mov     dword ptr [edi+8],eax
    mov     eax,dword ptr [edi+12t]
    adc     eax,ebp
    mov     dword ptr [edi+12t],eax

    sub     ecx,1
    jne     @la24f

    pop     edi
    pop     esi
    pop     ebp
    pop     ebx
    ret
_test_a24f ENDP


;;
;; test a24g - increment memory, read-modify-write using INC
;; 

    ECHO TEST A24g

_test_a24g PROC
    mov     ecx,cLOOPS*cINSTR

    align 16t

@la24g:
    inc     dword ptr rglongs+0
    inc     dword ptr rglongs+4
    add     dword ptr rgquads+0,1
    adc     dword ptr rgquads+4,0
    add     dword ptr rgquads+8,1
    adc     dword ptr rgquads+12t,0

    sub     ecx,1
    jne     @la24g

    ret
_test_a24g ENDP


;;
;; test a24h - increment memory, read-modify-write using ADD constant
;; 

    ECHO TEST A24h

_test_a24h PROC
    mov     ecx,cLOOPS*cINSTR

    align 16t

@la24h:
    add     dword ptr rglongs+0,1
    add     dword ptr rglongs+4,1
    add     dword ptr rgquads+0,1
    adc     dword ptr rgquads+4,0
    add     dword ptr rgquads+8,1
    adc     dword ptr rgquads+12t,0

    sub     ecx,1
    jne     @la24h

    ret
_test_a24h ENDP


;;
;; test a24i - increment memory, read-modify-write using INC / ADD reg
;; 

    ECHO TEST A24i

_test_a24i PROC
    mov     ecx,cLOOPS*cINSTR
    mov     eax,1
    mov     edx,0

    align 16t

@la24i:
    inc     dword ptr rglongs+0
    inc     dword ptr rglongs+4
    add     dword ptr rgquads+0,eax
    adc     dword ptr rgquads+4,edx
    add     dword ptr rgquads+8,eax
    adc     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24i

    ret
_test_a24i ENDP


;;
;; test a24j - increment memory, read-modify-write using ADD reg
;; 

    ECHO TEST A24j

_test_a24j PROC
    mov     ecx,cLOOPS*cINSTR
    mov     eax,1
    mov     edx,0

    align 16t

@la24j:
    add     dword ptr rglongs+0,eax
    add     dword ptr rglongs+4,eax
    add     dword ptr rgquads+0,eax
    adc     dword ptr rgquads+4,edx
    add     dword ptr rgquads+8,eax
    adc     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24j

    ret
_test_a24j ENDP


;;
;; test a24k - increment memory, using ADD from memory to register and store
;; 

    ECHO TEST A24k

_test_a24k PROC
    mov     ecx,cLOOPS*cINSTR

    align 16t

@la24k:
    mov     eax,1
    add     eax,dword ptr rglongs+0
    mov     dword ptr rglongs+0,eax
    mov     eax,1
    add     eax,dword ptr rglongs+4
    mov     dword ptr rglongs+4,eax
    mov     eax,1
    add     eax,dword ptr rgquads+0
    mov     edx,0
    adc     edx,dword ptr rgquads+4
    mov     dword ptr rgquads+0,eax
    mov     dword ptr rgquads+4,edx
    mov     eax,1
    add     eax,dword ptr rgquads+8
    mov     edx,0
    adc     edx,dword ptr rgquads+12t
    mov     dword ptr rgquads+8,eax
    mov     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24k

    ret
_test_a24k ENDP


;;
;; test a24l - increment memory, using proposed 3-operand ADD mem-to-reg
;; 

    ECHO TEST A24l

_test_a24l PROC
    mov     ecx,cLOOPS*cINSTR
    push    ebx

    align 16t

@la24l:
    add     eax,dword ptr rglongs+0
    mov     dword ptr rglongs+0,eax
    add     ebx,dword ptr rglongs+4
    mov     dword ptr rglongs+4,ebx
    add     edx,dword ptr rgquads+0
    adc     eax,dword ptr rgquads+4
    mov     dword ptr rgquads+0,edx
    mov     dword ptr rgquads+4,eax
    add     ebx,dword ptr rgquads+8
    adc     edx,dword ptr rgquads+12t
    mov     dword ptr rgquads+8,ebx
    mov     dword ptr rgquads+12t,edx

    sub     ecx,1
    jne     @la24l

    pop     ebx
    ret
_test_a24l ENDP