asma: anscheinend werden nur 8 bytes statt 16 behandelt :/

diff --git a/asma/asma.s b/asma/asma.s
index c2d663cae89e8f4c0cd7596e07ee6ed8e8b41930..a6294b47a24317f83ed943ea0de1e04b5fcba298 100644 (file)
--- a/asma/asma.s
+++ b/asma/asma.s
@@ -4,71 +4,50 @@
        .type   asma, @function
 asma:
 .LFB2:
-
-/* 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
-       pxor %xmm2, %xmm3
-       pxor %xmm2, %xmm4
-       pxor %xmm2, %xmm5
-
-       #init %xmm1 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
+       /*init %xmm1 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 */
        mov $0x9a9a9a9a9a9a9a9a, %rbx
        movq %rbx, %xmm1
        pslldq $8, %xmm1
        movq %rbx, %xmm1
 
-       #init %xmm2 mit "'a'-'A'= 97-65 = 32 = 0x20
+       //init %xmm2 mit "'a'-'A'= 97-65 = 32 = 0x20
        mov $0x2020202020202020, %rbx
        movq %rbx, %xmm2
        pslldq $8, %xmm2
        movq %rbx, %xmm2
 
-       #speicheradresse des pointers zeigt auf 16*8 feld = 128bit
+       //speicheradresse des pointers zeigt auf 16*8 feld = 128bit
        movdqu (%rdi), %xmm4
        movdqu (%rdi), %xmm5
 
-       #addiere in %xmm4 "min_t-'A'"
-       # = -128 - 65 = 63 = 0x3f
+       /*addiere in %xmm4 "min_t-'A'"
+       * = -128 - 65 = 63 = 0x3f */
        mov $0x3f3f3f3f3f3f3f3f, %rbx
        movq %rbx, %xmm3
        pslldq $8, %xmm3
        movq %rbx, %xmm3
 
-       #c+min_t-'A'
+       //c+min_t-'A'
        paddb %xmm3, %xmm4
 
-       #"Packed COMpare Greater Than (Byte)"
-       #bla = 'Z' + 1 + min_t - 'A' > c + min_t - 'A' ? 0xff : 0
-       #TODO: vllt vertauschen?
+       /*"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 %xmm4, %xmm1
 
-       #min(bla, 'a' - 'A')
-       pminub %xmm1, %xmm2
+       //Y = min(X, 'a' - 'A')
+       pminub %xmm2, %xmm1
 
-       paddb %xmm2, %xmm5
+       //c += Y
+       paddb %xmm1, %xmm5
 
+       //retuniere an die richtige speicheradresse
+       mov %rdi, %rax
        movq %xmm5, (%rax)
        ret
 .LFE2:

diff --git a/asma/main.c b/asma/main.c
index 6fb685290daedc6c09557dc89ab749d0a40c9b4f..4db42e6557a8fdbad8e2de973c00acb002a4531a 100644 (file)
--- a/asma/main.c
+++ b/asma/main.c
@@ -16,14 +16,14 @@ unsigned char *asma_ref(unsigned char *s)
 }
 
 int main(int argc, char **argv) {
-       char *input1[]={"asdfABCDEFGHKL54", "foofuuMUHkk", "AbC"};
+       char *input1[]={"asdfABCDEFGHKL54", "foofuuMUHkk", "AbC", "BLA|MUHMKUH|KA"};
        char *output1;
        char *output2;
        char *input2;
        char *input3;
        int i, j;
 
-       for(i = 0; i < 3; i++) {
+       for(i = 0; i < 4; i++) {
                input2 = strdup(input1[i]);
                input3 = strdup(input1[i]);
                output1 = (char *)asma_ref((unsigned char *)(input2));