asma: formel "umgeformt" und im endeffekt einen befehl "gewonnen" (haha)

[uebersetzerbau-ss10.git] / asma / asma.s

diff --git a/asma/asma.s b/asma/asma.s
index 1edcffc761df40e49c53c8d07399410de9021b25..9ea72d32ba5a7e8e62c46648c08337ada17bd5be 100644 (file)
--- a/asma/asma.s
+++ b/asma/asma.s
@@ -1,55 +1,61 @@
        .file   "asma.c"
+
+.section .rodata
+.align 128
+const65:
+       .rept 16
+       .byte 0x65
+       .endr
+const20:
+       .rept 16
+       .byte 0x20
+       .endr
+constc0:
+       .rept 16
+       .byte 0xc0
+       .endr
+
        .text
 .globl asma
        .type   asma, @function
 asma:
 .LFB2:
+       // folgendes kann umgeformt werden:
+       // (mathematisch ned ganz korrekt)
+       // X = 'Z' + 1 + min_t - 'A' > c + min_t - 'A' ? 0xff : 0
+       // X = -102         >  c + 63 ? 0xff : 0
+       // X = c + 63       < -102 ? 0xff : 0
+       // X = -(c + 63)    >  102 ? 0xff : 0
+       // X = -63 - c      >  102 ? 0xff : 0
+       // X = -63 - c - 1  >  102 - 1 ? 0xff : 0
+       // X = -64 - c      >  101 ? 0xff : 0
+       // ...
+       // 101 = 0x65
+       // -64 = 0xc0
 
-/* unsigned char *asma(unsigned char *s)  
-{  
-  int i;  
-  for (i=0; i<16; i++) {  
-    unsigned char c=s[i];  
-    c += (c>=’A’ && c<=’Z’) ? ’a’-’A’ : 0;  
-    s[i] = c;  
-  }  
-  return s;  
-}
-
-Schreiben Sie diese Funktion in Assembler unter Verwendung von pcmpgtb. Dabei ist folgende Äquivalenz hilfreich:
-(c>=’A’ && c<=’Z’) ? ’a’-’A’ : 0;
-
-ist (bei Verwendung von Überlauf-Arithmetik) äquivalent zu
-min(’Z’+1+min_t-’A’ > c+min_t-’A’ ? 0xff : 0, ’a’-’A’)
-
-wobei min_t der minimale Wert des Datentyps ist, den der Vergleich behandelt (bei pcmpgtb also -128). Zusätzlich zu dem oben genannten dürften die Befehle pminub, paddb, und psubb nützlich sein. */
-       pxor %xmm1, %xmm1
-       pxor %xmm2, %xmm2
-
-       #init %xmm2 mit "'Z' + 1" fuer jedes byte
-       mov $0x5a5a5a5a5a5a5a5a, %rbx
-       movq %rbx, %xmm2
-       pslldq $8, %xmm2
-       movq %rbx, %xmm2
+       // speicheradresse des pointers zeigt auf 16*8 feld = 128bit
+       movdqu (%rdi), %xmm11
 
-       #init %xmm4 mit "'a'-'A'= 97-65 = 32 = 0x20
-       mov $0x2020202020202020, %rbx
-       movq %rbx, %xmm4
-       pslldq $8, %xmm4
-       movq %rbx, %xmm4
+       // -64 - c
+       movdqa constc0, %xmm9
+       psubb %xmm11, %xmm9
 
-       #speicheradresse des pointers zeigt auf 16*8 feld = 128bit
-       movdqu (%rdi), %xmm1
-       movdqu (%rdi), %xmm3
+       // "Packed COMpare Greater Than (Byte)"
+       // achtung beim intuitiven lesen des befehles. 'kleiner'
+       // ist mit 'groesser' vertauscht und vice versa
+       pcmpgtb const65, %xmm9
 
-       #"Packed COMpare Greater Than (Byte)"
-       pcmpgtb %xmm2, %xmm1
+       // Y = min(X, 'a' - 'A')
+       // mit 'a'-'A'= 97-65 = 32 = 0x20
+       pminub const20, %xmm9
 
-       pminub %xmm4, %xmm1
+       // c += Y
+       paddb %xmm9, %xmm11
 
-       paddb %xmm1, %xmm3
+       // retuniere an die richtige speicheradresse
+       mov %rdi, %rax
+       movdqu %xmm11, (%rax)
 
-       movq %xmm3, (%rax)
        ret
 .LFE2:
        .size   asma, .-asma