asmb: erkenntnisse aus asma reingebastelt :)

diff --git a/asmb/asmb.s b/asmb/asmb.s
index e46b6b05662418ad5b6dae681219c5718d4b10ca..b2cdf72382bf64a1c592d3e24fb09e1548838495 100644 (file)
--- a/asmb/asmb.s
+++ b/asmb/asmb.s
@@ -1,19 +1,19 @@
        .file   "asmb.c"
 .section .rodata
 .align 128
-const9a:
+const65:
        .rept 16
-       .byte 0x9a
+       .byte 0x65
        .endr
 const20:
        .rept 16
        .byte 0x20
        .endr
-const3f:
+constc0:
        .rept 16
-       .byte 0x3f
+       .byte 0xc0
        .endr
-
+.section .rodata
        .text
 .globl asmb
        .type   asmb, @function
@@ -24,51 +24,33 @@ asmb:
        //soll einfach null sein
        pxor %xmm14, %xmm14
 
-       /*init %xmm8 mit "'Z' + 1 + min_t - 'A'" fuer jedes byte
-       * 'Z' + 1 + min_t - 'A' = 90 + 1 - 128 - 65 = -102
-       * 102 = 01100110
-       * ~102 = 10011001
-       * (~102)+1 = 10011010 = 0x9A */
-       movdqa const9a, %xmm8
-
-       //init %xmm9 mit "'a'-'A'= 97-65 = 32 = 0x20
-       movdqa const20, %xmm9
-
-       /*addiere in %xmm11 "min_t-'A'"
-       * = -128 - 65 = 63 = 0x3f */
-       movdqa const3f, %xmm10
-
 .nextround:
        //speicheradresse des pointers zeigt auf 16*8 feld = 128bit
        movdqu (%rdi, %rdx, 8), %xmm11
-       movdqu (%rdi, %rdx, 8), %xmm12
-
-       //c+min_t-'A'
-       paddb %xmm10, %xmm11
 
-       //0x9a9a... zwischenspeichern
-       movdqa %xmm8, %xmm15
+       // -64 - c
+       movdqa constc0, %xmm9
+       psubb %xmm11, %xmm9
 
-       /*"Packed COMpare Greater Than (Byte)"
-       * X = 'Z' + 1 + min_t - 'A' > c + min_t - 'A' ? 0xff : 0
-       * achtung beim intuitiven lesen des befehles. 'kleiner' 
-       * ist mit 'groesser' vertauscht und vice versa */
-       pcmpgtb %xmm11, %xmm15
+       // Packed COMpare Greater Than (Byte)"
+       // achtung beim intuitiven lesen des befehles. 'kleiner'
+       // ist mit 'groesser' vertauscht und vice versa
+       pcmpgtb const65, %xmm9
 
 .differenz:
-       //Y = min(X, 'a' - 'A')
-       pminub %xmm9, %xmm15
+       // Y = min(X, 'a' - 'A')
+       pminub const20, %xmm9
 
-       //c += Y
-       paddb %xmm15, %xmm12
+       // c += Y
+       paddb %xmm9, %xmm11
 
-       //retuniere an die richtige speicheradresse
-       movapd %xmm12, (%rdi, %rdx, 8)
+       // retuniere an die richtige speicheradresse
+       movdqu %xmm11, (%rdi, %rdx, 8)
 
        //entspricht ein byte dem nullbyte dann steht an jener stelle 0xff sonst 0x00
-       pcmpeqb %xmm14, %xmm12
+       pcmpeqb %xmm14, %xmm11
        //hol die MSBs aller bytes raus
-       pmovmskb %xmm12, %ecx
+       pmovmskb %xmm11, %ecx
        add $2, %rdx
 
        //ist %ecx gleich null? dann die naechsten 16byte bitte
@@ -87,53 +69,53 @@ asmb:
        //das ergebnis zweimal abspeichern
        mov %r11d, %ecx
 
-       //hint: in %xmm15 ist differenz gespeichert (vgl .differenz)
+       //hint: in %xmm9 ist differenz gespeichert (vgl .differenz)
 
        //leider shiften nur mit immediate! :(
        btr $3, %r11d
        jnc .rechtsshift1
-       psrldq $8, %xmm15
+       psrldq $8, %xmm9
 
 .rechtsshift1:
        btr $2, %r11d
        jnc .rechtsshift2
-       psrldq $4, %xmm15
+       psrldq $4, %xmm9
 
 .rechtsshift2:
        btr $1, %r11d
        jnc .rechtsshift3
-       psrldq $2, %xmm15
+       psrldq $2, %xmm9
 
 .rechtsshift3:
        btr $0, %r11d
        jnc .linksshift
-       psrldq $1, %xmm15
+       psrldq $1, %xmm9
 #==================
 .linksshift:
        btr $3, %ecx
        jnc .linksshift1
-       pslldq $8, %xmm15
+       pslldq $8, %xmm9
 
 .linksshift1:
        btr $2, %ecx
        jnc .linksshift2
-       pslldq $4, %xmm15
+       pslldq $4, %xmm9
 
 .linksshift2:
        btr $1, %ecx
        jnc .linksshift3
-       pslldq $2, %xmm15
+       pslldq $2, %xmm9
 
 .linksshift3:
        btr $0, %ecx
        jnc .endshift
-       pslldq $1, %xmm15
+       pslldq $1, %xmm9
 
 .endshift:
        //betreffende speicherstelle in %xmm11 laden
        movdqu -16(%rax, %rdx, 8), %xmm11
        //und overhead wieder subtrahieren
-       psubb %xmm15, %xmm11
+       psubb %xmm9, %xmm11
 
        //ergebnis zurueckspielen und fertig \o/
        movapd %xmm11, -16(%rax, %rdx, 8)