s390x assembler pack update from HEAD.
authorAndy Polyakov <appro@openssl.org>
Mon, 14 Nov 2011 20:47:22 +0000 (20:47 +0000)
committerAndy Polyakov <appro@openssl.org>
Mon, 14 Nov 2011 20:47:22 +0000 (20:47 +0000)
crypto/aes/asm/aes-s390x.pl
crypto/bn/asm/s390x-gf2m.pl [new file with mode: 0644]
crypto/bn/asm/s390x-mont.pl
crypto/rc4/asm/rc4-s390x.pl
crypto/s390xcap.c
crypto/s390xcpuid.S
crypto/sha/asm/sha1-s390x.pl
crypto/sha/asm/sha512-s390x.pl

index c15059c..687bdd9 100644 (file)
@@ -28,7 +28,7 @@
 
 # May 2007.
 #
 
 # May 2007.
 #
-# Implement private_AES_set_[en|de]crypt_key. Key schedule setup is avoided
+# Implement AES_set_[en|de]crypt_key. Key schedule setup is avoided
 # for 128-bit keys, if hardware support is detected.
 
 # Januray 2009.
 # for 128-bit keys, if hardware support is detected.
 
 # Januray 2009.
 # Unlike previous version hardware support detection takes place only
 # at the moment of key schedule setup, which is denoted in key->rounds.
 # This is done, because deferred key setup can't be made MT-safe, not
 # Unlike previous version hardware support detection takes place only
 # at the moment of key schedule setup, which is denoted in key->rounds.
 # This is done, because deferred key setup can't be made MT-safe, not
-# for key lengthes longer than 128 bits.
+# for keys longer than 128 bits.
 #
 # Add AES_cbc_encrypt, which gives incredible performance improvement,
 # it was measured to be ~6.6x. It's less than previously mentioned 8x,
 # because software implementation was optimized.
 
 #
 # Add AES_cbc_encrypt, which gives incredible performance improvement,
 # it was measured to be ~6.6x. It's less than previously mentioned 8x,
 # because software implementation was optimized.
 
+# May 2010.
+#
+# Add AES_ctr32_encrypt. If hardware-assisted, it provides up to 4.3x
+# performance improvement over "generic" counter mode routine relying
+# on single-block, also hardware-assisted, AES_encrypt. "Up to" refers
+# to the fact that exact throughput value depends on current stack
+# frame alignment within 4KB page. In worst case you get ~75% of the
+# maximum, but *on average* it would be as much as ~98%. Meaning that
+# worst case is unlike, it's like hitting ravine on plateau.
+
+# November 2010.
+#
+# Adapt for -m31 build. If kernel supports what's called "highgprs"
+# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
+# instructions and achieve "64-bit" performance even in 31-bit legacy
+# application context. The feature is not specific to any particular
+# processor, as long as it's "z-CPU". Latter implies that the code
+# remains z/Architecture specific. On z990 it was measured to perform
+# 2x better than code generated by gcc 4.3.
+
+# December 2010.
+#
+# Add support for z196 "cipher message with counter" instruction.
+# Note however that it's disengaged, because it was measured to
+# perform ~12% worse than vanilla km-based code...
+
+# February 2011.
+#
+# Add AES_xts_[en|de]crypt. This includes support for z196 km-xts-aes
+# instructions, which deliver ~70% improvement at 8KB block size over
+# vanilla km-based code, 37% - at most like 512-bytes block size.
+
+$flavour = shift;
+
+if ($flavour =~ /3[12]/) {
+       $SIZE_T=4;
+       $g="";
+} else {
+       $SIZE_T=8;
+       $g="g";
+}
+
+while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
+open STDOUT,">$output";
+
 $softonly=0;   # allow hardware support
 
 $t0="%r0";     $mask="%r0";
 $softonly=0;   # allow hardware support
 
 $t0="%r0";     $mask="%r0";
@@ -69,6 +114,8 @@ $rounds="%r13";
 $ra="%r14";
 $sp="%r15";
 
 $ra="%r14";
 $sp="%r15";
 
+$stdframe=16*$SIZE_T+4*8;
+
 sub _data_word()
 { my $i;
     while(defined($i=shift)) { $code.=sprintf".long\t0x%08x,0x%08x\n",$i,$i; }
 sub _data_word()
 { my $i;
     while(defined($i=shift)) { $code.=sprintf".long\t0x%08x,0x%08x\n",$i,$i; }
@@ -210,7 +257,7 @@ $code.=<<___ if (!$softonly);
 .Lesoft:
 ___
 $code.=<<___;
 .Lesoft:
 ___
 $code.=<<___;
-       stmg    %r3,$ra,24($sp)
+       stm${g} %r3,$ra,3*$SIZE_T($sp)
 
        llgf    $s0,0($inp)
        llgf    $s1,4($inp)
 
        llgf    $s0,0($inp)
        llgf    $s1,4($inp)
@@ -220,20 +267,20 @@ $code.=<<___;
        larl    $tbl,AES_Te
        bras    $ra,_s390x_AES_encrypt
 
        larl    $tbl,AES_Te
        bras    $ra,_s390x_AES_encrypt
 
-       lg      $out,24($sp)
+       l${g}   $out,3*$SIZE_T($sp)
        st      $s0,0($out)
        st      $s1,4($out)
        st      $s2,8($out)
        st      $s3,12($out)
 
        st      $s0,0($out)
        st      $s1,4($out)
        st      $s2,8($out)
        st      $s3,12($out)
 
-       lmg     %r6,$ra,48($sp)
+       lm${g}  %r6,$ra,6*$SIZE_T($sp)
        br      $ra
 .size  AES_encrypt,.-AES_encrypt
 
 .type   _s390x_AES_encrypt,\@function
 .align 16
 _s390x_AES_encrypt:
        br      $ra
 .size  AES_encrypt,.-AES_encrypt
 
 .type   _s390x_AES_encrypt,\@function
 .align 16
 _s390x_AES_encrypt:
-       stg     $ra,152($sp)
+       st${g}  $ra,15*$SIZE_T($sp)
        x       $s0,0($key)
        x       $s1,4($key)
        x       $s2,8($key)
        x       $s0,0($key)
        x       $s1,4($key)
        x       $s2,8($key)
@@ -397,7 +444,7 @@ _s390x_AES_encrypt:
        or      $s2,$i3
        or      $s3,$t3
 
        or      $s2,$i3
        or      $s3,$t3
 
-       lg      $ra,152($sp)
+       l${g}   $ra,15*$SIZE_T($sp)
        xr      $s0,$t0
        xr      $s1,$t2
        x       $s2,24($key)
        xr      $s0,$t0
        xr      $s1,$t2
        x       $s2,24($key)
@@ -536,7 +583,7 @@ $code.=<<___ if (!$softonly);
 .Ldsoft:
 ___
 $code.=<<___;
 .Ldsoft:
 ___
 $code.=<<___;
-       stmg    %r3,$ra,24($sp)
+       stm${g} %r3,$ra,3*$SIZE_T($sp)
 
        llgf    $s0,0($inp)
        llgf    $s1,4($inp)
 
        llgf    $s0,0($inp)
        llgf    $s1,4($inp)
@@ -546,20 +593,20 @@ $code.=<<___;
        larl    $tbl,AES_Td
        bras    $ra,_s390x_AES_decrypt
 
        larl    $tbl,AES_Td
        bras    $ra,_s390x_AES_decrypt
 
-       lg      $out,24($sp)
+       l${g}   $out,3*$SIZE_T($sp)
        st      $s0,0($out)
        st      $s1,4($out)
        st      $s2,8($out)
        st      $s3,12($out)
 
        st      $s0,0($out)
        st      $s1,4($out)
        st      $s2,8($out)
        st      $s3,12($out)
 
-       lmg     %r6,$ra,48($sp)
+       lm${g}  %r6,$ra,6*$SIZE_T($sp)
        br      $ra
 .size  AES_decrypt,.-AES_decrypt
 
 .type   _s390x_AES_decrypt,\@function
 .align 16
 _s390x_AES_decrypt:
        br      $ra
 .size  AES_decrypt,.-AES_decrypt
 
 .type   _s390x_AES_decrypt,\@function
 .align 16
 _s390x_AES_decrypt:
-       stg     $ra,152($sp)
+       st${g}  $ra,15*$SIZE_T($sp)
        x       $s0,0($key)
        x       $s1,4($key)
        x       $s2,8($key)
        x       $s0,0($key)
        x       $s1,4($key)
        x       $s2,8($key)
@@ -703,7 +750,7 @@ _s390x_AES_decrypt:
        nr      $i1,$mask
        nr      $i2,$mask
 
        nr      $i1,$mask
        nr      $i2,$mask
 
-       lg      $ra,152($sp)
+       l${g}   $ra,15*$SIZE_T($sp)
        or      $s1,$t1
        l       $t0,16($key)
        l       $t1,20($key)
        or      $s1,$t1
        l       $t0,16($key)
        l       $t1,20($key)
@@ -730,16 +777,16 @@ _s390x_AES_decrypt:
 ___
 
 $code.=<<___;
 ___
 
 $code.=<<___;
-# void private_AES_set_encrypt_key(const unsigned char *in, int bits,
+# void AES_set_encrypt_key(const unsigned char *in, int bits,
 #               AES_KEY *key) {
 #               AES_KEY *key) {
-.globl private_AES_set_encrypt_key
-.type  private_AES_set_encrypt_key,\@function
+.globl AES_set_encrypt_key
+.type  AES_set_encrypt_key,\@function
 .align 16
 .align 16
-private_AES_set_encrypt_key:
+AES_set_encrypt_key:
        lghi    $t0,0
        lghi    $t0,0
-       clgr    $inp,$t0
+       cl${g}r $inp,$t0
        je      .Lminus1
        je      .Lminus1
-       clgr    $key,$t0
+       cl${g}r $key,$t0
        je      .Lminus1
 
        lghi    $t0,128
        je      .Lminus1
 
        lghi    $t0,128
@@ -797,7 +844,7 @@ ___
 $code.=<<___;
 .align 16
 .Lekey_internal:
 $code.=<<___;
 .align 16
 .Lekey_internal:
-       stmg    %r6,%r13,48($sp)        # all non-volatile regs
+       stm${g} %r6,%r13,6*$SIZE_T($sp) # all non-volatile regs
 
        larl    $tbl,AES_Te+2048
 
 
        larl    $tbl,AES_Te+2048
 
@@ -858,7 +905,7 @@ $code.=<<___;
        la      $t3,4($t3)              # i++
        brct    $rounds,.L128_loop
        lghi    %r2,0
        la      $t3,4($t3)              # i++
        brct    $rounds,.L128_loop
        lghi    %r2,0
-       lmg     %r6,%r13,48($sp)
+       lm${g}  %r6,%r13,6*$SIZE_T($sp)
        br      $ra
 
 .align 16
        br      $ra
 
 .align 16
@@ -906,7 +953,7 @@ $code.=<<___;
        st      $s3,36($key)
        brct    $rounds,.L192_continue
        lghi    %r2,0
        st      $s3,36($key)
        brct    $rounds,.L192_continue
        lghi    %r2,0
-       lmg     %r6,%r13,48($sp)
+       lm${g}  %r6,%r13,6*$SIZE_T($sp)
        br      $ra
 
 .align 16
        br      $ra
 
 .align 16
@@ -968,7 +1015,7 @@ $code.=<<___;
        st      $s3,44($key)
        brct    $rounds,.L256_continue
        lghi    %r2,0
        st      $s3,44($key)
        brct    $rounds,.L256_continue
        lghi    %r2,0
-       lmg     %r6,%r13,48($sp)
+       lm${g}  %r6,%r13,6*$SIZE_T($sp)
        br      $ra
 
 .align 16
        br      $ra
 
 .align 16
@@ -1011,19 +1058,19 @@ $code.=<<___;
 .Lminus1:
        lghi    %r2,-1
        br      $ra
 .Lminus1:
        lghi    %r2,-1
        br      $ra
-.size  private_AES_set_encrypt_key,.-private_AES_set_encrypt_key
+.size  AES_set_encrypt_key,.-AES_set_encrypt_key
 
 
-# void private_AES_set_decrypt_key(const unsigned char *in, int bits,
+# void AES_set_decrypt_key(const unsigned char *in, int bits,
 #               AES_KEY *key) {
 #               AES_KEY *key) {
-.globl private_AES_set_decrypt_key
-.type  private_AES_set_decrypt_key,\@function
+.globl AES_set_decrypt_key
+.type  AES_set_decrypt_key,\@function
 .align 16
 .align 16
-private_AES_set_decrypt_key:
-       stg     $key,32($sp)            # I rely on private_AES_set_encrypt_key to
-       stg     $ra,112($sp)            # save non-volatile registers!
-       bras    $ra,private_AES_set_encrypt_key
-       lg      $key,32($sp)
-       lg      $ra,112($sp)
+AES_set_decrypt_key:
+       st${g}  $key,4*$SIZE_T($sp)     # I rely on AES_set_encrypt_key to
+       st${g}  $ra,14*$SIZE_T($sp)     # save non-volatile registers!
+       bras    $ra,AES_set_encrypt_key
+       l${g}   $key,4*$SIZE_T($sp)
+       l${g}   $ra,14*$SIZE_T($sp)
        ltgr    %r2,%r2
        bnzr    $ra
 ___
        ltgr    %r2,%r2
        bnzr    $ra
 ___
@@ -1038,11 +1085,11 @@ $code.=<<___ if (!$softonly);
 
 .align 16
 .Ldkey_internal:
 
 .align 16
 .Ldkey_internal:
-       stg     $key,32($sp)
-       stg     $ra,40($sp)
+       st${g}  $key,4*$SIZE_T($sp)
+       st${g}  $ra,14*$SIZE_T($sp)
        bras    $ra,.Lekey_internal
        bras    $ra,.Lekey_internal
-       lg      $key,32($sp)
-       lg      $ra,40($sp)
+       l${g}   $key,4*$SIZE_T($sp)
+       l${g}   $ra,14*$SIZE_T($sp)
 ___
 $code.=<<___;
 
 ___
 $code.=<<___;
 
@@ -1123,13 +1170,14 @@ $code.=<<___;
        la      $key,4($key)
        brct    $rounds,.Lmix
 
        la      $key,4($key)
        brct    $rounds,.Lmix
 
-       lmg     %r6,%r13,48($sp)# as was saved by private_AES_set_encrypt_key!
+       lm${g}  %r6,%r13,6*$SIZE_T($sp)# as was saved by AES_set_encrypt_key!
        lghi    %r2,0
        br      $ra
        lghi    %r2,0
        br      $ra
-.size  private_AES_set_decrypt_key,.-private_AES_set_decrypt_key
+.size  AES_set_decrypt_key,.-AES_set_decrypt_key
 ___
 
 ___
 
-#void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
+########################################################################
+# void AES_cbc_encrypt(const unsigned char *in, unsigned char *out,
 #                     size_t length, const AES_KEY *key,
 #                     unsigned char *ivec, const int enc)
 {
 #                     size_t length, const AES_KEY *key,
 #                     unsigned char *ivec, const int enc)
 {
@@ -1163,7 +1211,7 @@ $code.=<<___ if (!$softonly);
        l       %r0,240($key)   # load kmc code
        lghi    $key,15         # res=len%16, len-=res;
        ngr     $key,$len
        l       %r0,240($key)   # load kmc code
        lghi    $key,15         # res=len%16, len-=res;
        ngr     $key,$len
-       slgr    $len,$key
+       sl${g}r $len,$key
        la      %r1,16($sp)     # parameter block - ivec || key
        jz      .Lkmc_truncated
        .long   0xb92f0042      # kmc %r4,%r2
        la      %r1,16($sp)     # parameter block - ivec || key
        jz      .Lkmc_truncated
        .long   0xb92f0042      # kmc %r4,%r2
@@ -1181,34 +1229,34 @@ $code.=<<___ if (!$softonly);
        tmll    %r0,0x80
        jnz     .Lkmc_truncated_dec
        lghi    %r1,0
        tmll    %r0,0x80
        jnz     .Lkmc_truncated_dec
        lghi    %r1,0
-       stg     %r1,128($sp)
-       stg     %r1,136($sp)
+       stg     %r1,16*$SIZE_T($sp)
+       stg     %r1,16*$SIZE_T+8($sp)
        bras    %r1,1f
        bras    %r1,1f
-       mvc     128(1,$sp),0($inp)
+       mvc     16*$SIZE_T(1,$sp),0($inp)
 1:     ex      $key,0(%r1)
        la      %r1,16($sp)     # restore parameter block
 1:     ex      $key,0(%r1)
        la      %r1,16($sp)     # restore parameter block
-       la      $inp,128($sp)
+       la      $inp,16*$SIZE_T($sp)
        lghi    $len,16
        .long   0xb92f0042      # kmc %r4,%r2
        j       .Lkmc_done
 .align 16
 .Lkmc_truncated_dec:
        lghi    $len,16
        .long   0xb92f0042      # kmc %r4,%r2
        j       .Lkmc_done
 .align 16
 .Lkmc_truncated_dec:
-       stg     $out,64($sp)
-       la      $out,128($sp)
+       st${g}  $out,4*$SIZE_T($sp)
+       la      $out,16*$SIZE_T($sp)
        lghi    $len,16
        .long   0xb92f0042      # kmc %r4,%r2
        lghi    $len,16
        .long   0xb92f0042      # kmc %r4,%r2
-       lg      $out,64($sp)
+       l${g}   $out,4*$SIZE_T($sp)
        bras    %r1,2f
        bras    %r1,2f
-       mvc     0(1,$out),128($sp)
+       mvc     0(1,$out),16*$SIZE_T($sp)
 2:     ex      $key,0(%r1)
        j       .Lkmc_done
 .align 16
 .Lcbc_software:
 ___
 $code.=<<___;
 2:     ex      $key,0(%r1)
        j       .Lkmc_done
 .align 16
 .Lcbc_software:
 ___
 $code.=<<___;
-       stmg    $key,$ra,40($sp)
+       stm${g} $key,$ra,5*$SIZE_T($sp)
        lhi     %r0,0
        lhi     %r0,0
-       cl      %r0,164($sp)
+       cl      %r0,`$stdframe+$SIZE_T-4`($sp)
        je      .Lcbc_decrypt
 
        larl    $tbl,AES_Te
        je      .Lcbc_decrypt
 
        larl    $tbl,AES_Te
@@ -1219,10 +1267,10 @@ $code.=<<___;
        llgf    $s3,12($ivp)
 
        lghi    $t0,16
        llgf    $s3,12($ivp)
 
        lghi    $t0,16
-       slgr    $len,$t0
+       sl${g}r $len,$t0
        brc     4,.Lcbc_enc_tail        # if borrow
 .Lcbc_enc_loop:
        brc     4,.Lcbc_enc_tail        # if borrow
 .Lcbc_enc_loop:
-       stmg    $inp,$out,16($sp)
+       stm${g} $inp,$out,2*$SIZE_T($sp)
        x       $s0,0($inp)
        x       $s1,4($inp)
        x       $s2,8($inp)
        x       $s0,0($inp)
        x       $s1,4($inp)
        x       $s2,8($inp)
@@ -1231,7 +1279,7 @@ $code.=<<___;
 
        bras    $ra,_s390x_AES_encrypt
 
 
        bras    $ra,_s390x_AES_encrypt
 
-       lmg     $inp,$key,16($sp)
+       lm${g}  $inp,$key,2*$SIZE_T($sp)
        st      $s0,0($out)
        st      $s1,4($out)
        st      $s2,8($out)
        st      $s0,0($out)
        st      $s1,4($out)
        st      $s2,8($out)
@@ -1240,33 +1288,33 @@ $code.=<<___;
        la      $inp,16($inp)
        la      $out,16($out)
        lghi    $t0,16
        la      $inp,16($inp)
        la      $out,16($out)
        lghi    $t0,16
-       ltgr    $len,$len
+       lt${g}r $len,$len
        jz      .Lcbc_enc_done
        jz      .Lcbc_enc_done
-       slgr    $len,$t0
+       sl${g}r $len,$t0
        brc     4,.Lcbc_enc_tail        # if borrow
        j       .Lcbc_enc_loop
 .align 16
 .Lcbc_enc_done:
        brc     4,.Lcbc_enc_tail        # if borrow
        j       .Lcbc_enc_loop
 .align 16
 .Lcbc_enc_done:
-       lg      $ivp,48($sp)
+       l${g}   $ivp,6*$SIZE_T($sp)
        st      $s0,0($ivp)
        st      $s1,4($ivp)     
        st      $s2,8($ivp)
        st      $s3,12($ivp)
 
        st      $s0,0($ivp)
        st      $s1,4($ivp)     
        st      $s2,8($ivp)
        st      $s3,12($ivp)
 
-       lmg     %r7,$ra,56($sp)
+       lm${g}  %r7,$ra,7*$SIZE_T($sp)
        br      $ra
 
 .align 16
 .Lcbc_enc_tail:
        aghi    $len,15
        lghi    $t0,0
        br      $ra
 
 .align 16
 .Lcbc_enc_tail:
        aghi    $len,15
        lghi    $t0,0
-       stg     $t0,128($sp)
-       stg     $t0,136($sp)
+       stg     $t0,16*$SIZE_T($sp)
+       stg     $t0,16*$SIZE_T+8($sp)
        bras    $t1,3f
        bras    $t1,3f
-       mvc     128(1,$sp),0($inp)
+       mvc     16*$SIZE_T(1,$sp),0($inp)
 3:     ex      $len,0($t1)
        lghi    $len,0
 3:     ex      $len,0($t1)
        lghi    $len,0
-       la      $inp,128($sp)
+       la      $inp,16*$SIZE_T($sp)
        j       .Lcbc_enc_loop
 
 .align 16
        j       .Lcbc_enc_loop
 
 .align 16
@@ -1275,10 +1323,10 @@ $code.=<<___;
 
        lg      $t0,0($ivp)
        lg      $t1,8($ivp)
 
        lg      $t0,0($ivp)
        lg      $t1,8($ivp)
-       stmg    $t0,$t1,128($sp)
+       stmg    $t0,$t1,16*$SIZE_T($sp)
 
 .Lcbc_dec_loop:
 
 .Lcbc_dec_loop:
-       stmg    $inp,$out,16($sp)
+       stm${g} $inp,$out,2*$SIZE_T($sp)
        llgf    $s0,0($inp)
        llgf    $s1,4($inp)
        llgf    $s2,8($inp)
        llgf    $s0,0($inp)
        llgf    $s1,4($inp)
        llgf    $s2,8($inp)
@@ -1287,7 +1335,7 @@ $code.=<<___;
 
        bras    $ra,_s390x_AES_decrypt
 
 
        bras    $ra,_s390x_AES_decrypt
 
-       lmg     $inp,$key,16($sp)
+       lm${g}  $inp,$key,2*$SIZE_T($sp)
        sllg    $s0,$s0,32
        sllg    $s2,$s2,32
        lr      $s0,$s1
        sllg    $s0,$s0,32
        sllg    $s2,$s2,32
        lr      $s0,$s1
@@ -1295,15 +1343,15 @@ $code.=<<___;
 
        lg      $t0,0($inp)
        lg      $t1,8($inp)
 
        lg      $t0,0($inp)
        lg      $t1,8($inp)
-       xg      $s0,128($sp)
-       xg      $s2,136($sp)
+       xg      $s0,16*$SIZE_T($sp)
+       xg      $s2,16*$SIZE_T+8($sp)
        lghi    $s1,16
        lghi    $s1,16
-       slgr    $len,$s1
+       sl${g}r $len,$s1
        brc     4,.Lcbc_dec_tail        # if borrow
        brc     2,.Lcbc_dec_done        # if zero
        stg     $s0,0($out)
        stg     $s2,8($out)
        brc     4,.Lcbc_dec_tail        # if borrow
        brc     2,.Lcbc_dec_done        # if zero
        stg     $s0,0($out)
        stg     $s2,8($out)
-       stmg    $t0,$t1,128($sp)
+       stmg    $t0,$t1,16*$SIZE_T($sp)
 
        la      $inp,16($inp)
        la      $out,16($out)
 
        la      $inp,16($inp)
        la      $out,16($out)
@@ -1313,7 +1361,7 @@ $code.=<<___;
        stg     $s0,0($out)
        stg     $s2,8($out)
 .Lcbc_dec_exit:
        stg     $s0,0($out)
        stg     $s2,8($out)
 .Lcbc_dec_exit:
-       lmg     $ivp,$ra,48($sp)
+       lm${g}  %r6,$ra,6*$SIZE_T($sp)
        stmg    $t0,$t1,0($ivp)
 
        br      $ra
        stmg    $t0,$t1,0($ivp)
 
        br      $ra
@@ -1321,19 +1369,889 @@ $code.=<<___;
 .align 16
 .Lcbc_dec_tail:
        aghi    $len,15
 .align 16
 .Lcbc_dec_tail:
        aghi    $len,15
-       stg     $s0,128($sp)
-       stg     $s2,136($sp)
+       stg     $s0,16*$SIZE_T($sp)
+       stg     $s2,16*$SIZE_T+8($sp)
        bras    $s1,4f
        bras    $s1,4f
-       mvc     0(1,$out),128($sp)
+       mvc     0(1,$out),16*$SIZE_T($sp)
 4:     ex      $len,0($s1)
        j       .Lcbc_dec_exit
 .size  AES_cbc_encrypt,.-AES_cbc_encrypt
 4:     ex      $len,0($s1)
        j       .Lcbc_dec_exit
 .size  AES_cbc_encrypt,.-AES_cbc_encrypt
-.comm  OPENSSL_s390xcap_P,8,8
+___
+}
+########################################################################
+# void AES_ctr32_encrypt(const unsigned char *in, unsigned char *out,
+#                     size_t blocks, const AES_KEY *key,
+#                     const unsigned char *ivec)
+{
+my $inp="%r2";
+my $out="%r4"; # blocks and out are swapped
+my $len="%r3";
+my $key="%r5"; my $iv0="%r5";
+my $ivp="%r6";
+my $fp ="%r7";
+
+$code.=<<___;
+.globl AES_ctr32_encrypt
+.type  AES_ctr32_encrypt,\@function
+.align 16
+AES_ctr32_encrypt:
+       xgr     %r3,%r4         # flip %r3 and %r4, $out and $len
+       xgr     %r4,%r3
+       xgr     %r3,%r4
+       llgfr   $len,$len       # safe in ctr32 subroutine even in 64-bit case
+___
+$code.=<<___ if (!$softonly);
+       l       %r0,240($key)
+       lhi     %r1,16
+       clr     %r0,%r1
+       jl      .Lctr32_software
+
+       stm${g} %r6,$s3,6*$SIZE_T($sp)
+
+       slgr    $out,$inp
+       la      %r1,0($key)     # %r1 is permanent copy of $key
+       lg      $iv0,0($ivp)    # load ivec
+       lg      $ivp,8($ivp)
+
+       # prepare and allocate stack frame at the top of 4K page
+       # with 1K reserved for eventual signal handling
+       lghi    $s0,-1024-256-16# guarantee at least 256-bytes buffer
+       lghi    $s1,-4096
+       algr    $s0,$sp
+       lgr     $fp,$sp
+       ngr     $s0,$s1         # align at page boundary
+       slgr    $fp,$s0         # total buffer size
+       lgr     $s2,$sp
+       lghi    $s1,1024+16     # sl[g]fi is extended-immediate facility
+       slgr    $fp,$s1         # deduct reservation to get usable buffer size
+       # buffer size is at lest 256 and at most 3072+256-16
+
+       la      $sp,1024($s0)   # alloca
+       srlg    $fp,$fp,4       # convert bytes to blocks, minimum 16
+       st${g}  $s2,0($sp)      # back-chain
+       st${g}  $fp,$SIZE_T($sp)
+
+       slgr    $len,$fp
+       brc     1,.Lctr32_hw_switch     # not zero, no borrow
+       algr    $fp,$len        # input is shorter than allocated buffer
+       lghi    $len,0
+       st${g}  $fp,$SIZE_T($sp)
+
+.Lctr32_hw_switch:
+___
+$code.=<<___ if (0);   ######### kmctr code was measured to be ~12% slower
+       larl    $s0,OPENSSL_s390xcap_P
+       lg      $s0,8($s0)
+       tmhh    $s0,0x0004      # check for message_security-assist-4
+       jz      .Lctr32_km_loop
+
+       llgfr   $s0,%r0
+       lgr     $s1,%r1
+       lghi    %r0,0
+       la      %r1,16($sp)
+       .long   0xb92d2042      # kmctr %r4,%r2,%r2
+
+       llihh   %r0,0x8000      # check if kmctr supports the function code
+       srlg    %r0,%r0,0($s0)
+       ng      %r0,16($sp)
+       lgr     %r0,$s0
+       lgr     %r1,$s1
+       jz      .Lctr32_km_loop
+
+####### kmctr code
+       algr    $out,$inp       # restore $out
+       lgr     $s1,$len        # $s1 undertakes $len
+       j       .Lctr32_kmctr_loop
+.align 16
+.Lctr32_kmctr_loop:
+       la      $s2,16($sp)
+       lgr     $s3,$fp
+.Lctr32_kmctr_prepare:
+       stg     $iv0,0($s2)
+       stg     $ivp,8($s2)
+       la      $s2,16($s2)
+       ahi     $ivp,1          # 32-bit increment, preserves upper half
+       brct    $s3,.Lctr32_kmctr_prepare
+
+       #la     $inp,0($inp)    # inp
+       sllg    $len,$fp,4      # len
+       #la     $out,0($out)    # out
+       la      $s2,16($sp)     # iv
+       .long   0xb92da042      # kmctr $out,$s2,$inp
+       brc     1,.-4           # pay attention to "partial completion"
+
+       slgr    $s1,$fp
+       brc     1,.Lctr32_kmctr_loop    # not zero, no borrow
+       algr    $fp,$s1
+       lghi    $s1,0
+       brc     4+1,.Lctr32_kmctr_loop  # not zero
+
+       l${g}   $sp,0($sp)
+       lm${g}  %r6,$s3,6*$SIZE_T($sp)
+       br      $ra
+.align 16
+___
+$code.=<<___;
+.Lctr32_km_loop:
+       la      $s2,16($sp)
+       lgr     $s3,$fp
+.Lctr32_km_prepare:
+       stg     $iv0,0($s2)
+       stg     $ivp,8($s2)
+       la      $s2,16($s2)
+       ahi     $ivp,1          # 32-bit increment, preserves upper half
+       brct    $s3,.Lctr32_km_prepare
+
+       la      $s0,16($sp)     # inp
+       sllg    $s1,$fp,4       # len
+       la      $s2,16($sp)     # out
+       .long   0xb92e00a8      # km %r10,%r8
+       brc     1,.-4           # pay attention to "partial completion"
+
+       la      $s2,16($sp)
+       lgr     $s3,$fp
+       slgr    $s2,$inp
+.Lctr32_km_xor:
+       lg      $s0,0($inp)
+       lg      $s1,8($inp)
+       xg      $s0,0($s2,$inp)
+       xg      $s1,8($s2,$inp)
+       stg     $s0,0($out,$inp)
+       stg     $s1,8($out,$inp)
+       la      $inp,16($inp)
+       brct    $s3,.Lctr32_km_xor
+
+       slgr    $len,$fp
+       brc     1,.Lctr32_km_loop       # not zero, no borrow
+       algr    $fp,$len
+       lghi    $len,0
+       brc     4+1,.Lctr32_km_loop     # not zero
+
+       l${g}   $s0,0($sp)
+       l${g}   $s1,$SIZE_T($sp)
+       la      $s2,16($sp)
+.Lctr32_km_zap:
+       stg     $s0,0($s2)
+       stg     $s0,8($s2)
+       la      $s2,16($s2)
+       brct    $s1,.Lctr32_km_zap
+
+       la      $sp,0($s0)
+       lm${g}  %r6,$s3,6*$SIZE_T($sp)
+       br      $ra
+.align 16
+.Lctr32_software:
+___
+$code.=<<___;
+       stm${g} $key,$ra,5*$SIZE_T($sp)
+       sl${g}r $inp,$out
+       larl    $tbl,AES_Te
+       llgf    $t1,12($ivp)
+
+.Lctr32_loop:
+       stm${g} $inp,$out,2*$SIZE_T($sp)
+       llgf    $s0,0($ivp)
+       llgf    $s1,4($ivp)
+       llgf    $s2,8($ivp)
+       lgr     $s3,$t1
+       st      $t1,16*$SIZE_T($sp)
+       lgr     %r4,$key
+
+       bras    $ra,_s390x_AES_encrypt
+
+       lm${g}  $inp,$ivp,2*$SIZE_T($sp)
+       llgf    $t1,16*$SIZE_T($sp)
+       x       $s0,0($inp,$out)
+       x       $s1,4($inp,$out)
+       x       $s2,8($inp,$out)
+       x       $s3,12($inp,$out)
+       stm     $s0,$s3,0($out)
+
+       la      $out,16($out)
+       ahi     $t1,1           # 32-bit increment
+       brct    $len,.Lctr32_loop
+
+       lm${g}  %r6,$ra,6*$SIZE_T($sp)
+       br      $ra
+.size  AES_ctr32_encrypt,.-AES_ctr32_encrypt
+___
+}
+
+########################################################################
+# void AES_xts_encrypt(const char *inp,char *out,size_t len,
+#      const AES_KEY *key1, const AES_KEY *key2,
+#      const unsigned char iv[16]);
+#
+{
+my $inp="%r2";
+my $out="%r4"; # len and out are swapped
+my $len="%r3";
+my $key1="%r5";        # $i1
+my $key2="%r6";        # $i2
+my $fp="%r7";  # $i3
+my $tweak=16*$SIZE_T+16;       # or $stdframe-16, bottom of the frame...
+
+$code.=<<___;
+.type  _s390x_xts_km,\@function
+.align 16
+_s390x_xts_km:
+___
+$code.=<<___ if(1);
+       llgfr   $s0,%r0                 # put aside the function code
+       lghi    $s1,0x7f
+       nr      $s1,%r0
+       lghi    %r0,0                   # query capability vector
+       la      %r1,2*$SIZE_T($sp)
+       .long   0xb92e0042              # km %r4,%r2
+       llihh   %r1,0x8000
+       srlg    %r1,%r1,32($s1)         # check for 32+function code
+       ng      %r1,2*$SIZE_T($sp)
+       lgr     %r0,$s0                 # restore the function code
+       la      %r1,0($key1)            # restore $key1
+       jz      .Lxts_km_vanilla
+
+       lmg     $i2,$i3,$tweak($sp)     # put aside the tweak value
+       algr    $out,$inp
+
+       oill    %r0,32                  # switch to xts function code
+       aghi    $s1,-18                 #
+       sllg    $s1,$s1,3               # (function code - 18)*8, 0 or 16
+       la      %r1,$tweak-16($sp)
+       slgr    %r1,$s1                 # parameter block position
+       lmg     $s0,$s3,0($key1)        # load 256 bits of key material,
+       stmg    $s0,$s3,0(%r1)          # and copy it to parameter block.
+                                       # yes, it contains junk and overlaps
+                                       # with the tweak in 128-bit case.
+                                       # it's done to avoid conditional
+                                       # branch.
+       stmg    $i2,$i3,$tweak($sp)     # "re-seat" the tweak value
+
+       .long   0xb92e0042              # km %r4,%r2
+       brc     1,.-4                   # pay attention to "partial completion"
+
+       lrvg    $s0,$tweak+0($sp)       # load the last tweak
+       lrvg    $s1,$tweak+8($sp)
+       stmg    %r0,%r3,$tweak-32(%r1)  # wipe copy of the key
+
+       nill    %r0,0xffdf              # switch back to original function code
+       la      %r1,0($key1)            # restore pointer to $key1
+       slgr    $out,$inp
+
+       llgc    $len,2*$SIZE_T-1($sp)
+       nill    $len,0x0f               # $len%=16
+       br      $ra
+       
+.align 16
+.Lxts_km_vanilla:
+___
+$code.=<<___;
+       # prepare and allocate stack frame at the top of 4K page
+       # with 1K reserved for eventual signal handling
+       lghi    $s0,-1024-256-16# guarantee at least 256-bytes buffer
+       lghi    $s1,-4096
+       algr    $s0,$sp
+       lgr     $fp,$sp
+       ngr     $s0,$s1         # align at page boundary
+       slgr    $fp,$s0         # total buffer size
+       lgr     $s2,$sp
+       lghi    $s1,1024+16     # sl[g]fi is extended-immediate facility
+       slgr    $fp,$s1         # deduct reservation to get usable buffer size
+       # buffer size is at lest 256 and at most 3072+256-16
+
+       la      $sp,1024($s0)   # alloca
+       nill    $fp,0xfff0      # round to 16*n
+       st${g}  $s2,0($sp)      # back-chain
+       nill    $len,0xfff0     # redundant
+       st${g}  $fp,$SIZE_T($sp)
+
+       slgr    $len,$fp
+       brc     1,.Lxts_km_go   # not zero, no borrow
+       algr    $fp,$len        # input is shorter than allocated buffer
+       lghi    $len,0
+       st${g}  $fp,$SIZE_T($sp)
+
+.Lxts_km_go:
+       lrvg    $s0,$tweak+0($s2)       # load the tweak value in little-endian
+       lrvg    $s1,$tweak+8($s2)
+
+       la      $s2,16($sp)             # vector of ascending tweak values
+       slgr    $s2,$inp
+       srlg    $s3,$fp,4
+       j       .Lxts_km_start
+
+.Lxts_km_loop:
+       la      $s2,16($sp)
+       slgr    $s2,$inp
+       srlg    $s3,$fp,4
+.Lxts_km_prepare:
+       lghi    $i1,0x87
+       srag    $i2,$s1,63              # broadcast upper bit
+       ngr     $i1,$i2                 # rem
+       srlg    $i2,$s0,63              # carry bit from lower half
+       sllg    $s0,$s0,1
+       sllg    $s1,$s1,1
+       xgr     $s0,$i1
+       ogr     $s1,$i2
+.Lxts_km_start:
+       lrvgr   $i1,$s0                 # flip byte order
+       lrvgr   $i2,$s1
+       stg     $i1,0($s2,$inp)
+       stg     $i2,8($s2,$inp)
+       xg      $i1,0($inp)
+       xg      $i2,8($inp)
+       stg     $i1,0($out,$inp)
+       stg     $i2,8($out,$inp)
+       la      $inp,16($inp)
+       brct    $s3,.Lxts_km_prepare
+
+       slgr    $inp,$fp                # rewind $inp
+       la      $s2,0($out,$inp)
+       lgr     $s3,$fp
+       .long   0xb92e00aa              # km $s2,$s2
+       brc     1,.-4                   # pay attention to "partial completion"
+
+       la      $s2,16($sp)
+       slgr    $s2,$inp
+       srlg    $s3,$fp,4
+.Lxts_km_xor:
+       lg      $i1,0($out,$inp)
+       lg      $i2,8($out,$inp)
+       xg      $i1,0($s2,$inp)
+       xg      $i2,8($s2,$inp)
+       stg     $i1,0($out,$inp)
+       stg     $i2,8($out,$inp)
+       la      $inp,16($inp)
+       brct    $s3,.Lxts_km_xor
+
+       slgr    $len,$fp
+       brc     1,.Lxts_km_loop         # not zero, no borrow
+       algr    $fp,$len
+       lghi    $len,0
+       brc     4+1,.Lxts_km_loop       # not zero
+
+       l${g}   $i1,0($sp)              # back-chain
+       llgf    $fp,`2*$SIZE_T-4`($sp)  # bytes used
+       la      $i2,16($sp)
+       srlg    $fp,$fp,4
+.Lxts_km_zap:
+       stg     $i1,0($i2)
+       stg     $i1,8($i2)
+       la      $i2,16($i2)
+       brct    $fp,.Lxts_km_zap
+
+       la      $sp,0($i1)
+       llgc    $len,2*$SIZE_T-1($i1)
+       nill    $len,0x0f               # $len%=16
+       bzr     $ra
+
+       # generate one more tweak...
+       lghi    $i1,0x87
+       srag    $i2,$s1,63              # broadcast upper bit
+       ngr     $i1,$i2                 # rem
+       srlg    $i2,$s0,63              # carry bit from lower half
+       sllg    $s0,$s0,1
+       sllg    $s1,$s1,1
+       xgr     $s0,$i1
+       ogr     $s1,$i2
+
+       ltr     $len,$len               # clear zero flag
+       br      $ra
+.size  _s390x_xts_km,.-_s390x_xts_km
+
+.globl AES_xts_encrypt
+.type  AES_xts_encrypt,\@function
+.align 16
+AES_xts_encrypt:
+       xgr     %r3,%r4                 # flip %r3 and %r4, $out and $len
+       xgr     %r4,%r3
+       xgr     %r3,%r4
+___
+$code.=<<___ if ($SIZE_T==4);
+       llgfr   $len,$len
+___
+$code.=<<___;
+       st${g}  $len,1*$SIZE_T($sp)     # save copy of $len
+       srag    $len,$len,4             # formally wrong, because it expands
+                                       # sign byte, but who can afford asking
+                                       # to process more than 2^63-1 bytes?
+                                       # I use it, because it sets condition
+                                       # code...
+       bcr     8,$ra                   # abort if zero (i.e. less than 16)
+___
+$code.=<<___ if (!$softonly);
+       llgf    %r0,240($key2)
+       lhi     %r1,16
+       clr     %r0,%r1
+       jl      .Lxts_enc_software
+
+       stm${g} %r6,$s3,6*$SIZE_T($sp)
+       st${g}  $ra,14*$SIZE_T($sp)
+
+       sllg    $len,$len,4             # $len&=~15
+       slgr    $out,$inp
+
+       # generate the tweak value
+       l${g}   $s3,$stdframe($sp)      # pointer to iv
+       la      $s2,$tweak($sp)
+       lmg     $s0,$s1,0($s3)
+       lghi    $s3,16
+       stmg    $s0,$s1,0($s2)
+       la      %r1,0($key2)            # $key2 is not needed anymore
+       .long   0xb92e00aa              # km $s2,$s2, generate the tweak
+       brc     1,.-4                   # can this happen?
+
+       l       %r0,240($key1)
+       la      %r1,0($key1)            # $key1 is not needed anymore
+       bras    $ra,_s390x_xts_km
+       jz      .Lxts_enc_km_done
+
+       aghi    $inp,-16                # take one step back
+       la      $i3,0($out,$inp)        # put aside real $out
+.Lxts_enc_km_steal:
+       llgc    $i1,16($inp)
+       llgc    $i2,0($out,$inp)
+       stc     $i1,0($out,$inp)
+       stc     $i2,16($out,$inp)
+       la      $inp,1($inp)
+       brct    $len,.Lxts_enc_km_steal
+
+       la      $s2,0($i3)
+       lghi    $s3,16
+       lrvgr   $i1,$s0                 # flip byte order
+       lrvgr   $i2,$s1
+       xg      $i1,0($s2)
+       xg      $i2,8($s2)
+       stg     $i1,0($s2)
+       stg     $i2,8($s2)
+       .long   0xb92e00aa              # km $s2,$s2
+       brc     1,.-4                   # can this happen?
+       lrvgr   $i1,$s0                 # flip byte order
+       lrvgr   $i2,$s1
+       xg      $i1,0($i3)
+       xg      $i2,8($i3)
+       stg     $i1,0($i3)
+       stg     $i2,8($i3)
+
+.Lxts_enc_km_done:
+       l${g}   $ra,14*$SIZE_T($sp)
+       st${g}  $sp,$tweak($sp)         # wipe tweak
+       st${g}  $sp,$tweak($sp)
+       lm${g}  %r6,$s3,6*$SIZE_T($sp)
+       br      $ra
+.align 16
+.Lxts_enc_software:
+___
+$code.=<<___;
+       stm${g} %r6,$ra,6*$SIZE_T($sp)
+
+       slgr    $out,$inp
+
+       xgr     $s0,$s0                 # clear upper half
+       xgr     $s1,$s1
+       lrv     $s0,$stdframe+4($sp)    # load secno
+       lrv     $s1,$stdframe+0($sp)
+       xgr     $s2,$s2
+       xgr     $s3,$s3
+       stm${g} %r2,%r5,2*$SIZE_T($sp)
+       la      $key,0($key2)
+       larl    $tbl,AES_Te
+       bras    $ra,_s390x_AES_encrypt  # generate the tweak
+       lm${g}  %r2,%r5,2*$SIZE_T($sp)
+       stm     $s0,$s3,$tweak($sp)     # save the tweak
+       j       .Lxts_enc_enter
+
+.align 16
+.Lxts_enc_loop:
+       lrvg    $s1,$tweak+0($sp)       # load the tweak in little-endian
+       lrvg    $s3,$tweak+8($sp)
+       lghi    %r1,0x87
+       srag    %r0,$s3,63              # broadcast upper bit
+       ngr     %r1,%r0                 # rem
+       srlg    %r0,$s1,63              # carry bit from lower half
+       sllg    $s1,$s1,1
+       sllg    $s3,$s3,1
+       xgr     $s1,%r1
+       ogr     $s3,%r0
+       lrvgr   $s1,$s1                 # flip byte order
+       lrvgr   $s3,$s3
+       srlg    $s0,$s1,32              # smash the tweak to 4x32-bits 
+       stg     $s1,$tweak+0($sp)       # save the tweak
+       llgfr   $s1,$s1
+       srlg    $s2,$s3,32
+       stg     $s3,$tweak+8($sp)
+       llgfr   $s3,$s3
+       la      $inp,16($inp)           # $inp+=16
+.Lxts_enc_enter:
+       x       $s0,0($inp)             # ^=*($inp)
+       x       $s1,4($inp)
+       x       $s2,8($inp)
+       x       $s3,12($inp)
+       stm${g} %r2,%r3,2*$SIZE_T($sp)  # only two registers are changing
+       la      $key,0($key1)
+       bras    $ra,_s390x_AES_encrypt
+       lm${g}  %r2,%r5,2*$SIZE_T($sp)
+       x       $s0,$tweak+0($sp)       # ^=tweak
+       x       $s1,$tweak+4($sp)
+       x       $s2,$tweak+8($sp)
+       x       $s3,$tweak+12($sp)
+       st      $s0,0($out,$inp)
+       st      $s1,4($out,$inp)
+       st      $s2,8($out,$inp)
+       st      $s3,12($out,$inp)
+       brct${g}        $len,.Lxts_enc_loop
+
+       llgc    $len,`2*$SIZE_T-1`($sp)
+       nill    $len,0x0f               # $len%16
+       jz      .Lxts_enc_done
+
+       la      $i3,0($inp,$out)        # put aside real $out
+.Lxts_enc_steal:
+       llgc    %r0,16($inp)
+       llgc    %r1,0($out,$inp)
+       stc     %r0,0($out,$inp)
+       stc     %r1,16($out,$inp)
+       la      $inp,1($inp)
+       brct    $len,.Lxts_enc_steal
+       la      $out,0($i3)             # restore real $out
+
+       # generate last tweak...
+       lrvg    $s1,$tweak+0($sp)       # load the tweak in little-endian
+       lrvg    $s3,$tweak+8($sp)
+       lghi    %r1,0x87
+       srag    %r0,$s3,63              # broadcast upper bit
+       ngr     %r1,%r0                 # rem
+       srlg    %r0,$s1,63              # carry bit from lower half
+       sllg    $s1,$s1,1
+       sllg    $s3,$s3,1
+       xgr     $s1,%r1
+       ogr     $s3,%r0
+       lrvgr   $s1,$s1                 # flip byte order
+       lrvgr   $s3,$s3
+       srlg    $s0,$s1,32              # smash the tweak to 4x32-bits 
+       stg     $s1,$tweak+0($sp)       # save the tweak
+       llgfr   $s1,$s1
+       srlg    $s2,$s3,32
+       stg     $s3,$tweak+8($sp)
+       llgfr   $s3,$s3
+
+       x       $s0,0($out)             # ^=*(inp)|stolen cipther-text
+       x       $s1,4($out)
+       x       $s2,8($out)
+       x       $s3,12($out)
+       st${g}  $out,4*$SIZE_T($sp)
+       la      $key,0($key1)
+       bras    $ra,_s390x_AES_encrypt
+       l${g}   $out,4*$SIZE_T($sp)
+       x       $s0,`$tweak+0`($sp)     # ^=tweak
+       x       $s1,`$tweak+4`($sp)
+       x       $s2,`$tweak+8`($sp)
+       x       $s3,`$tweak+12`($sp)
+       st      $s0,0($out)
+       st      $s1,4($out)
+       st      $s2,8($out)
+       st      $s3,12($out)
+
+.Lxts_enc_done:
+       stg     $sp,$tweak+0($sp)       # wipe tweak
+       stg     $sp,$twesk+8($sp)
+       lm${g}  %r6,$ra,6*$SIZE_T($sp)
+       br      $ra
+.size  AES_xts_encrypt,.-AES_xts_encrypt
+___
+# void AES_xts_decrypt(const char *inp,char *out,size_t len,
+#      const AES_KEY *key1, const AES_KEY *key2,u64 secno);
+#
+$code.=<<___;
+.globl AES_xts_decrypt
+.type  AES_xts_decrypt,\@function
+.align 16
+AES_xts_decrypt:
+       xgr     %r3,%r4                 # flip %r3 and %r4, $out and $len
+       xgr     %r4,%r3
+       xgr     %r3,%r4
+___
+$code.=<<___ if ($SIZE_T==4);
+       llgfr   $len,$len
+___
+$code.=<<___;
+       st${g}  $len,1*$SIZE_T($sp)     # save copy of $len
+       aghi    $len,-16
+       bcr     4,$ra                   # abort if less than zero. formally
+                                       # wrong, because $len is unsigned,
+                                       # but who can afford asking to
+                                       # process more than 2^63-1 bytes?
+       tmll    $len,0x0f
+       jnz     .Lxts_dec_proceed
+       aghi    $len,16
+.Lxts_dec_proceed:
+___
+$code.=<<___ if (!$softonly);
+       llgf    %r0,240($key2)
+       lhi     %r1,16
+       clr     %r0,%r1
+       jl      .Lxts_dec_software
+
+       stm${g} %r6,$s3,6*$SIZE_T($sp)
+       st${g}  $ra,14*$SIZE_T($sp)
+
+       nill    $len,0xfff0             # $len&=~15
+       slgr    $out,$inp
+
+       # generate the tweak value
+       l${g}   $s3,$stdframe($sp)      # pointer to iv
+       la      $s2,$tweak($sp)
+       lmg     $s0,$s1,0($s3)
+       lghi    $s3,16
+       stmg    $s0,$s1,0($s2)
+       la      %r1,0($key2)            # $key2 is not needed past this point
+       .long   0xb92e00aa              # km $s2,$s2, generate the tweak
+       brc     1,.-4                   # can this happen?
+
+       l       %r0,240($key1)
+       la      %r1,0($key1)            # $key1 is not needed anymore
+
+       ltgr    $len,$len
+       jz      .Lxts_dec_km_short
+       bras    $ra,_s390x_xts_km
+       jz      .Lxts_dec_km_done
+
+       lrvgr   $s2,$s0                 # make copy in reverse byte order
+       lrvgr   $s3,$s1
+       j       .Lxts_dec_km_2ndtweak
+
+.Lxts_dec_km_short:
+       llgc    $len,`2*$SIZE_T-1`($sp)
+       nill    $len,0x0f               # $len%=16
+       lrvg    $s0,$tweak+0($sp)       # load the tweak
+       lrvg    $s1,$tweak+8($sp)
+       lrvgr   $s2,$s0                 # make copy in reverse byte order
+       lrvgr   $s3,$s1
+
+.Lxts_dec_km_2ndtweak:
+       lghi    $i1,0x87
+       srag    $i2,$s1,63              # broadcast upper bit
+       ngr     $i1,$i2                 # rem
+       srlg    $i2,$s0,63              # carry bit from lower half
+       sllg    $s0,$s0,1
+       sllg    $s1,$s1,1
+       xgr     $s0,$i1
+       ogr     $s1,$i2
+       lrvgr   $i1,$s0                 # flip byte order
+       lrvgr   $i2,$s1
+
+       xg      $i1,0($inp)
+       xg      $i2,8($inp)
+       stg     $i1,0($out,$inp)
+       stg     $i2,8($out,$inp)
+       la      $i2,0($out,$inp)
+       lghi    $i3,16
+       .long   0xb92e0066              # km $i2,$i2
+       brc     1,.-4                   # can this happen?
+       lrvgr   $i1,$s0
+       lrvgr   $i2,$s1
+       xg      $i1,0($out,$inp)
+       xg      $i2,8($out,$inp)
+       stg     $i1,0($out,$inp)
+       stg     $i2,8($out,$inp)
+
+       la      $i3,0($out,$inp)        # put aside real $out
+.Lxts_dec_km_steal:
+       llgc    $i1,16($inp)
+       llgc    $i2,0($out,$inp)
+       stc     $i1,0($out,$inp)
+       stc     $i2,16($out,$inp)
+       la      $inp,1($inp)
+       brct    $len,.Lxts_dec_km_steal
+
+       lgr     $s0,$s2
+       lgr     $s1,$s3
+       xg      $s0,0($i3)
+       xg      $s1,8($i3)
+       stg     $s0,0($i3)
+       stg     $s1,8($i3)
+       la      $s0,0($i3)
+       lghi    $s1,16
+       .long   0xb92e0088              # km $s0,$s0
+       brc     1,.-4                   # can this happen?
+       xg      $s2,0($i3)
+       xg      $s3,8($i3)
+       stg     $s2,0($i3)
+       stg     $s3,8($i3)
+.Lxts_dec_km_done:
+       l${g}   $ra,14*$SIZE_T($sp)
+       st${g}  $sp,$tweak($sp)         # wipe tweak
+       st${g}  $sp,$tweak($sp)
+       lm${g}  %r6,$s3,6*$SIZE_T($sp)
+       br      $ra
+.align 16
+.Lxts_dec_software:
+___
+$code.=<<___;
+       stm${g} %r6,$ra,6*$SIZE_T($sp)
+
+       srlg    $len,$len,4
+       slgr    $out,$inp
+
+       xgr     $s0,$s0                 # clear upper half
+       xgr     $s1,$s1
+       lrv     $s0,$stdframe+4($sp)    # load secno
+       lrv     $s1,$stdframe+0($sp)
+       xgr     $s2,$s2
+       xgr     $s3,$s3
+       stm${g} %r2,%r5,2*$SIZE_T($sp)
+       la      $key,0($key2)
+       larl    $tbl,AES_Te
+       bras    $ra,_s390x_AES_encrypt  # generate the tweak
+       lm${g}  %r2,%r5,2*$SIZE_T($sp)
+       larl    $tbl,AES_Td
+       lt${g}r $len,$len
+       stm     $s0,$s3,$tweak($sp)     # save the tweak
+       jz      .Lxts_dec_short
+       j       .Lxts_dec_enter
+
+.align 16
+.Lxts_dec_loop:
+       lrvg    $s1,$tweak+0($sp)       # load the tweak in little-endian
+       lrvg    $s3,$tweak+8($sp)
+       lghi    %r1,0x87
+       srag    %r0,$s3,63              # broadcast upper bit
+       ngr     %r1,%r0                 # rem
+       srlg    %r0,$s1,63              # carry bit from lower half
+       sllg    $s1,$s1,1
+       sllg    $s3,$s3,1
+       xgr     $s1,%r1
+       ogr     $s3,%r0
+       lrvgr   $s1,$s1                 # flip byte order
+       lrvgr   $s3,$s3
+       srlg    $s0,$s1,32              # smash the tweak to 4x32-bits 
+       stg     $s1,$tweak+0($sp)       # save the tweak
+       llgfr   $s1,$s1
+       srlg    $s2,$s3,32
+       stg     $s3,$tweak+8($sp)
+       llgfr   $s3,$s3
+.Lxts_dec_enter:
+       x       $s0,0($inp)             # tweak^=*(inp)
+       x       $s1,4($inp)
+       x       $s2,8($inp)
+       x       $s3,12($inp)
+       stm${g} %r2,%r3,2*$SIZE_T($sp)  # only two registers are changing
+       la      $key,0($key1)
+       bras    $ra,_s390x_AES_decrypt
+       lm${g}  %r2,%r5,2*$SIZE_T($sp)
+       x       $s0,$tweak+0($sp)       # ^=tweak
+       x       $s1,$tweak+4($sp)
+       x       $s2,$tweak+8($sp)
+       x       $s3,$tweak+12($sp)
+       st      $s0,0($out,$inp)
+       st      $s1,4($out,$inp)
+       st      $s2,8($out,$inp)
+       st      $s3,12($out,$inp)
+       la      $inp,16($inp)
+       brct${g}        $len,.Lxts_dec_loop
+
+       llgc    $len,`2*$SIZE_T-1`($sp)
+       nill    $len,0x0f               # $len%16
+       jz      .Lxts_dec_done
+
+       # generate pair of tweaks...
+       lrvg    $s1,$tweak+0($sp)       # load the tweak in little-endian
+       lrvg    $s3,$tweak+8($sp)
+       lghi    %r1,0x87
+       srag    %r0,$s3,63              # broadcast upper bit
+       ngr     %r1,%r0                 # rem
+       srlg    %r0,$s1,63              # carry bit from lower half
+       sllg    $s1,$s1,1
+       sllg    $s3,$s3,1
+       xgr     $s1,%r1
+       ogr     $s3,%r0
+       lrvgr   $i2,$s1                 # flip byte order
+       lrvgr   $i3,$s3
+       stmg    $i2,$i3,$tweak($sp)     # save the 1st tweak
+       j       .Lxts_dec_2ndtweak
+
+.align 16
+.Lxts_dec_short:
+       llgc    $len,`2*$SIZE_T-1`($sp)
+       nill    $len,0x0f               # $len%16
+       lrvg    $s1,$tweak+0($sp)       # load the tweak in little-endian
+       lrvg    $s3,$tweak+8($sp)
+.Lxts_dec_2ndtweak:
+       lghi    %r1,0x87
+       srag    %r0,$s3,63              # broadcast upper bit
+       ngr     %r1,%r0                 # rem
+       srlg    %r0,$s1,63              # carry bit from lower half
+       sllg    $s1,$s1,1
+       sllg    $s3,$s3,1
+       xgr     $s1,%r1
+       ogr     $s3,%r0
+       lrvgr   $s1,$s1                 # flip byte order
+       lrvgr   $s3,$s3
+       srlg    $s0,$s1,32              # smash the tweak to 4x32-bits
+       stg     $s1,$tweak-16+0($sp)    # save the 2nd tweak
+       llgfr   $s1,$s1
+       srlg    $s2,$s3,32
+       stg     $s3,$tweak-16+8($sp)
+       llgfr   $s3,$s3
+
+       x       $s0,0($inp)             # tweak_the_2nd^=*(inp)
+       x       $s1,4($inp)
+       x       $s2,8($inp)
+       x       $s3,12($inp)
+       stm${g} %r2,%r3,2*$SIZE_T($sp)
+       la      $key,0($key1)
+       bras    $ra,_s390x_AES_decrypt
+       lm${g}  %r2,%r5,2*$SIZE_T($sp)
+       x       $s0,$tweak-16+0($sp)    # ^=tweak_the_2nd
+       x       $s1,$tweak-16+4($sp)
+       x       $s2,$tweak-16+8($sp)
+       x       $s3,$tweak-16+12($sp)
+       st      $s0,0($out,$inp)
+       st      $s1,4($out,$inp)
+       st      $s2,8($out,$inp)
+       st      $s3,12($out,$inp)
+
+       la      $i3,0($out,$inp)        # put aside real $out
+.Lxts_dec_steal:
+       llgc    %r0,16($inp)
+       llgc    %r1,0($out,$inp)
+       stc     %r0,0($out,$inp)
+       stc     %r1,16($out,$inp)
+       la      $inp,1($inp)
+       brct    $len,.Lxts_dec_steal
+       la      $out,0($i3)             # restore real $out
+
+       lm      $s0,$s3,$tweak($sp)     # load the 1st tweak
+       x       $s0,0($out)             # tweak^=*(inp)|stolen cipher-text
+       x       $s1,4($out)
+       x       $s2,8($out)
+       x       $s3,12($out)
+       st${g}  $out,4*$SIZE_T($sp)
+       la      $key,0($key1)
+       bras    $ra,_s390x_AES_decrypt
+       l${g}   $out,4*$SIZE_T($sp)
+       x       $s0,$tweak+0($sp)       # ^=tweak
+       x       $s1,$tweak+4($sp)
+       x       $s2,$tweak+8($sp)
+       x       $s3,$tweak+12($sp)
+       st      $s0,0($out)
+       st      $s1,4($out)
+       st      $s2,8($out)
+       st      $s3,12($out)
+       stg     $sp,$tweak-16+0($sp)    # wipe 2nd tweak
+       stg     $sp,$tweak-16+8($sp)
+.Lxts_dec_done:
+       stg     $sp,$tweak+0($sp)       # wipe tweak
+       stg     $sp,$twesk+8($sp)
+       lm${g}  %r6,$ra,6*$SIZE_T($sp)
+       br      $ra
+.size  AES_xts_decrypt,.-AES_xts_decrypt
 ___
 }
 $code.=<<___;
 .string        "AES for s390x, CRYPTOGAMS by <appro\@openssl.org>"
 ___
 }
 $code.=<<___;
 .string        "AES for s390x, CRYPTOGAMS by <appro\@openssl.org>"
+.comm  OPENSSL_s390xcap_P,16,8
 ___
 
 $code =~ s/\`([^\`]*)\`/eval $1/gem;
 print $code;
 ___
 
 $code =~ s/\`([^\`]*)\`/eval $1/gem;
 print $code;
+close STDOUT;  # force flush
diff --git a/crypto/bn/asm/s390x-gf2m.pl b/crypto/bn/asm/s390x-gf2m.pl
new file mode 100644 (file)
index 0000000..cd9f13e
--- /dev/null
@@ -0,0 +1,221 @@
+#!/usr/bin/env perl
+#
+# ====================================================================
+# Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
+# project. The module is, however, dual licensed under OpenSSL and
+# CRYPTOGAMS licenses depending on where you obtain it. For further
+# details see http://www.openssl.org/~appro/cryptogams/.
+# ====================================================================
+#
+# May 2011
+#
+# The module implements bn_GF2m_mul_2x2 polynomial multiplication used
+# in bn_gf2m.c. It's kind of low-hanging mechanical port from C for
+# the time being... gcc 4.3 appeared to generate poor code, therefore
+# the effort. And indeed, the module delivers 55%-90%(*) improvement
+# on haviest ECDSA verify and ECDH benchmarks for 163- and 571-bit
+# key lengths on z990, 30%-55%(*) - on z10, and 70%-110%(*) - on z196.
+# This is for 64-bit build. In 32-bit "highgprs" case improvement is
+# even higher, for example on z990 it was measured 80%-150%. ECDSA
+# sign is modest 9%-12% faster. Keep in mind that these coefficients
+# are not ones for bn_GF2m_mul_2x2 itself, as not all CPU time is
+# burnt in it...
+#
+# (*)  gcc 4.1 was observed to deliver better results than gcc 4.3,
+#      so that improvement coefficients can vary from one specific
+#      setup to another.
+
+$flavour = shift;
+
+if ($flavour =~ /3[12]/) {
+        $SIZE_T=4;
+        $g="";
+} else {
+        $SIZE_T=8;
+        $g="g";
+}
+
+while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
+open STDOUT,">$output";
+
+$stdframe=16*$SIZE_T+4*8;
+
+$rp="%r2";
+$a1="%r3";
+$a0="%r4";
+$b1="%r5";
+$b0="%r6";
+
+$ra="%r14";
+$sp="%r15";
+
+@T=("%r0","%r1");
+@i=("%r12","%r13");
+
+($a1,$a2,$a4,$a8,$a12,$a48)=map("%r$_",(6..11));
+($lo,$hi,$b)=map("%r$_",(3..5)); $a=$lo; $mask=$a8;
+
+$code.=<<___;
+.text
+
+.type  _mul_1x1,\@function
+.align 16
+_mul_1x1:
+       lgr     $a1,$a
+       sllg    $a2,$a,1
+       sllg    $a4,$a,2
+       sllg    $a8,$a,3
+
+       srag    $lo,$a1,63                      # broadcast 63rd bit
+       nihh    $a1,0x1fff
+       srag    @i[0],$a2,63                    # broadcast 62nd bit
+       nihh    $a2,0x3fff
+       srag    @i[1],$a4,63                    # broadcast 61st bit
+       nihh    $a4,0x7fff
+       ngr     $lo,$b
+       ngr     @i[0],$b
+       ngr     @i[1],$b
+
+       lghi    @T[0],0
+       lgr     $a12,$a1
+       stg     @T[0],`$stdframe+0*8`($sp)      # tab[0]=0
+       xgr     $a12,$a2
+       stg     $a1,`$stdframe+1*8`($sp)        # tab[1]=a1
+        lgr    $a48,$a4
+       stg     $a2,`$stdframe+2*8`($sp)        # tab[2]=a2
+        xgr    $a48,$a8
+       stg     $a12,`$stdframe+3*8`($sp)       # tab[3]=a1^a2
+        xgr    $a1,$a4
+
+       stg     $a4,`$stdframe+4*8`($sp)        # tab[4]=a4
+       xgr     $a2,$a4
+       stg     $a1,`$stdframe+5*8`($sp)        # tab[5]=a1^a4
+       xgr     $a12,$a4
+       stg     $a2,`$stdframe+6*8`($sp)        # tab[6]=a2^a4
+        xgr    $a1,$a48
+       stg     $a12,`$stdframe+7*8`($sp)       # tab[7]=a1^a2^a4
+        xgr    $a2,$a48
+
+       stg     $a8,`$stdframe+8*8`($sp)        # tab[8]=a8
+       xgr     $a12,$a48
+       stg     $a1,`$stdframe+9*8`($sp)        # tab[9]=a1^a8
+        xgr    $a1,$a4
+       stg     $a2,`$stdframe+10*8`($sp)       # tab[10]=a2^a8
+        xgr    $a2,$a4
+       stg     $a12,`$stdframe+11*8`($sp)      # tab[11]=a1^a2^a8
+
+       xgr     $a12,$a4
+       stg     $a48,`$stdframe+12*8`($sp)      # tab[12]=a4^a8
+        srlg   $hi,$lo,1
+       stg     $a1,`$stdframe+13*8`($sp)       # tab[13]=a1^a4^a8
+        sllg   $lo,$lo,63
+       stg     $a2,`$stdframe+14*8`($sp)       # tab[14]=a2^a4^a8
+        srlg   @T[0],@i[0],2
+       stg     $a12,`$stdframe+15*8`($sp)      # tab[15]=a1^a2^a4^a8
+
+       lghi    $mask,`0xf<<3`
+       sllg    $a1,@i[0],62
+        sllg   @i[0],$b,3
+       srlg    @T[1],@i[1],3
+        ngr    @i[0],$mask
+       sllg    $a2,@i[1],61
+        srlg   @i[1],$b,4-3
+       xgr     $hi,@T[0]
+        ngr    @i[1],$mask
+       xgr     $lo,$a1
+       xgr     $hi,@T[1]
+       xgr     $lo,$a2
+
+       xg      $lo,$stdframe(@i[0],$sp)
+       srlg    @i[0],$b,8-3
+       ngr     @i[0],$mask
+___
+for($n=1;$n<14;$n++) {
+$code.=<<___;
+       lg      @T[1],$stdframe(@i[1],$sp)
+       srlg    @i[1],$b,`($n+2)*4`-3
+       sllg    @T[0],@T[1],`$n*4`
+       ngr     @i[1],$mask
+       srlg    @T[1],@T[1],`64-$n*4`
+       xgr     $lo,@T[0]
+       xgr     $hi,@T[1]
+___
+       push(@i,shift(@i)); push(@T,shift(@T));
+}
+$code.=<<___;
+       lg      @T[1],$stdframe(@i[1],$sp)
+       sllg    @T[0],@T[1],`$n*4`
+       srlg    @T[1],@T[1],`64-$n*4`
+       xgr     $lo,@T[0]
+       xgr     $hi,@T[1]
+
+       lg      @T[0],$stdframe(@i[0],$sp)
+       sllg    @T[1],@T[0],`($n+1)*4`
+       srlg    @T[0],@T[0],`64-($n+1)*4`
+       xgr     $lo,@T[1]
+       xgr     $hi,@T[0]
+
+       br      $ra
+.size  _mul_1x1,.-_mul_1x1
+
+.globl bn_GF2m_mul_2x2
+.type  bn_GF2m_mul_2x2,\@function
+.align 16
+bn_GF2m_mul_2x2:
+       stm${g} %r3,%r15,3*$SIZE_T($sp)
+
+       lghi    %r1,-$stdframe-128
+       la      %r0,0($sp)
+       la      $sp,0(%r1,$sp)                  # alloca
+       st${g}  %r0,0($sp)                      # back chain
+___
+if ($SIZE_T==8) {
+my @r=map("%r$_",(6..9));
+$code.=<<___;
+       bras    $ra,_mul_1x1                    # a1·b1
+       stmg    $lo,$hi,16($rp)
+
+       lg      $a,`$stdframe+128+4*$SIZE_T`($sp)
+       lg      $b,`$stdframe+128+6*$SIZE_T`($sp)
+       bras    $ra,_mul_1x1                    # a0·b0
+       stmg    $lo,$hi,0($rp)
+
+       lg      $a,`$stdframe+128+3*$SIZE_T`($sp)
+       lg      $b,`$stdframe+128+5*$SIZE_T`($sp)
+       xg      $a,`$stdframe+128+4*$SIZE_T`($sp)
+       xg      $b,`$stdframe+128+6*$SIZE_T`($sp)
+       bras    $ra,_mul_1x1                    # (a0+a1)·(b0+b1)
+       lmg     @r[0],@r[3],0($rp)
+
+       xgr     $lo,$hi
+       xgr     $hi,@r[1]
+       xgr     $lo,@r[0]
+       xgr     $hi,@r[2]
+       xgr     $lo,@r[3]       
+       xgr     $hi,@r[3]
+       xgr     $lo,$hi
+       stg     $hi,16($rp)
+       stg     $lo,8($rp)
+___
+} else {
+$code.=<<___;
+       sllg    %r3,%r3,32
+       sllg    %r5,%r5,32
+       or      %r3,%r4
+       or      %r5,%r6
+       bras    $ra,_mul_1x1
+       rllg    $lo,$lo,32
+       rllg    $hi,$hi,32
+       stmg    $lo,$hi,0($rp)
+___
+}
+$code.=<<___;
+       lm${g}  %r6,%r15,`$stdframe+128+6*$SIZE_T`($sp)
+       br      $ra
+.size  bn_GF2m_mul_2x2,.-bn_GF2m_mul_2x2
+.string        "GF(2^m) Multiplication for s390x, CRYPTOGAMS by <appro\@openssl.org>"
+___
+
+$code =~ s/\`([^\`]*)\`/eval($1)/gem;
+print $code;
+close STDOUT;
index f61246f..9fd64e8 100644 (file)
 # Reschedule to minimize/avoid Address Generation Interlock hazard,
 # make inner loops counter-based.
 
 # Reschedule to minimize/avoid Address Generation Interlock hazard,
 # make inner loops counter-based.
 
+# November 2010.
+#
+# Adapt for -m31 build. If kernel supports what's called "highgprs"
+# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
+# instructions and achieve "64-bit" performance even in 31-bit legacy
+# application context. The feature is not specific to any particular
+# processor, as long as it's "z-CPU". Latter implies that the code
+# remains z/Architecture specific. Compatibility with 32-bit BN_ULONG
+# is achieved by swapping words after 64-bit loads, follow _dswap-s.
+# On z990 it was measured to perform 2.6-2.2 times better than
+# compiler-generated code, less for longer keys...
+
+$flavour = shift;
+
+if ($flavour =~ /3[12]/) {
+       $SIZE_T=4;
+       $g="";
+} else {
+       $SIZE_T=8;
+       $g="g";
+}
+
+while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
+open STDOUT,">$output";
+
+$stdframe=16*$SIZE_T+4*8;
+
 $mn0="%r0";
 $num="%r1";
 
 $mn0="%r0";
 $num="%r1";
 
@@ -60,34 +87,44 @@ $code.=<<___;
 .globl bn_mul_mont
 .type  bn_mul_mont,\@function
 bn_mul_mont:
 .globl bn_mul_mont
 .type  bn_mul_mont,\@function
 bn_mul_mont:
-       lgf     $num,164($sp)   # pull $num
-       sla     $num,3          # $num to enumerate bytes
+       lgf     $num,`$stdframe+$SIZE_T-4`($sp) # pull $num
+       sla     $num,`log($SIZE_T)/log(2)`      # $num to enumerate bytes
        la      $bp,0($num,$bp)
 
        la      $bp,0($num,$bp)
 
-       stg     %r2,16($sp)
+       st${g}  %r2,2*$SIZE_T($sp)
 
        cghi    $num,16         #
        lghi    %r2,0           #
        blr     %r14            # if($num<16) return 0;
 
        cghi    $num,16         #
        lghi    %r2,0           #
        blr     %r14            # if($num<16) return 0;
+___
+$code.=<<___ if ($flavour =~ /3[12]/);
+       tmll    $num,4
+       bnzr    %r14            # if ($num&1) return 0;
+___
+$code.=<<___ if ($flavour !~ /3[12]/);
        cghi    $num,96         #
        bhr     %r14            # if($num>96) return 0;
        cghi    $num,96         #
        bhr     %r14            # if($num>96) return 0;
+___
+$code.=<<___;
+       stm${g} %r3,%r15,3*$SIZE_T($sp)
 
 
-       stmg    %r3,%r15,24($sp)
-
-       lghi    $rp,-160-8      # leave room for carry bit
+       lghi    $rp,-$stdframe-8        # leave room for carry bit
        lcgr    $j,$num         # -$num
        lgr     %r0,$sp
        la      $rp,0($rp,$sp)
        la      $sp,0($j,$rp)   # alloca
        lcgr    $j,$num         # -$num
        lgr     %r0,$sp
        la      $rp,0($rp,$sp)
        la      $sp,0($j,$rp)   # alloca
-       stg     %r0,0($sp)      # back chain
+       st${g}  %r0,0($sp)      # back chain
 
        sra     $num,3          # restore $num
        la      $bp,0($j,$bp)   # restore $bp
        ahi     $num,-1         # adjust $num for inner loop
        lg      $n0,0($n0)      # pull n0
 
        sra     $num,3          # restore $num
        la      $bp,0($j,$bp)   # restore $bp
        ahi     $num,-1         # adjust $num for inner loop
        lg      $n0,0($n0)      # pull n0
+       _dswap  $n0
 
        lg      $bi,0($bp)
 
        lg      $bi,0($bp)
+       _dswap  $bi
        lg      $alo,0($ap)
        lg      $alo,0($ap)
+       _dswap  $alo
        mlgr    $ahi,$bi        # ap[0]*bp[0]
        lgr     $AHI,$ahi
 
        mlgr    $ahi,$bi        # ap[0]*bp[0]
        lgr     $AHI,$ahi
 
@@ -95,6 +132,7 @@ bn_mul_mont:
        msgr    $mn0,$n0
 
        lg      $nlo,0($np)     #
        msgr    $mn0,$n0
 
        lg      $nlo,0($np)     #
+       _dswap  $nlo
        mlgr    $nhi,$mn0       # np[0]*m1
        algr    $nlo,$alo       # +="tp[0]"
        lghi    $NHI,0
        mlgr    $nhi,$mn0       # np[0]*m1
        algr    $nlo,$alo       # +="tp[0]"
        lghi    $NHI,0
@@ -106,12 +144,14 @@ bn_mul_mont:
 .align 16
 .L1st:
        lg      $alo,0($j,$ap)
 .align 16
 .L1st:
        lg      $alo,0($j,$ap)
+       _dswap  $alo
        mlgr    $ahi,$bi        # ap[j]*bp[0]
        algr    $alo,$AHI
        lghi    $AHI,0
        alcgr   $AHI,$ahi
 
        lg      $nlo,0($j,$np)
        mlgr    $ahi,$bi        # ap[j]*bp[0]
        algr    $alo,$AHI
        lghi    $AHI,0
        alcgr   $AHI,$ahi
 
        lg      $nlo,0($j,$np)
+       _dswap  $nlo
        mlgr    $nhi,$mn0       # np[j]*m1
        algr    $nlo,$NHI
        lghi    $NHI,0
        mlgr    $nhi,$mn0       # np[j]*m1
        algr    $nlo,$NHI
        lghi    $NHI,0
@@ -119,22 +159,24 @@ bn_mul_mont:
        algr    $nlo,$alo
        alcgr   $NHI,$nhi
 
        algr    $nlo,$alo
        alcgr   $NHI,$nhi
 
-       stg     $nlo,160-8($j,$sp)      # tp[j-1]=
+       stg     $nlo,$stdframe-8($j,$sp)        # tp[j-1]=
        la      $j,8($j)        # j++
        brct    $count,.L1st
 
        algr    $NHI,$AHI
        lghi    $AHI,0
        alcgr   $AHI,$AHI       # upmost overflow bit
        la      $j,8($j)        # j++
        brct    $count,.L1st
 
        algr    $NHI,$AHI
        lghi    $AHI,0
        alcgr   $AHI,$AHI       # upmost overflow bit
-       stg     $NHI,160-8($j,$sp)
-       stg     $AHI,160($j,$sp)
+       stg     $NHI,$stdframe-8($j,$sp)
+       stg     $AHI,$stdframe($j,$sp)
        la      $bp,8($bp)      # bp++
 
 .Louter:
        lg      $bi,0($bp)      # bp[i]
        la      $bp,8($bp)      # bp++
 
 .Louter:
        lg      $bi,0($bp)      # bp[i]
+       _dswap  $bi
        lg      $alo,0($ap)
        lg      $alo,0($ap)
+       _dswap  $alo
        mlgr    $ahi,$bi        # ap[0]*bp[i]
        mlgr    $ahi,$bi        # ap[0]*bp[i]
-       alg     $alo,160($sp)   # +=tp[0]
+       alg     $alo,$stdframe($sp)     # +=tp[0]
        lghi    $AHI,0
        alcgr   $AHI,$ahi
 
        lghi    $AHI,0
        alcgr   $AHI,$ahi
 
@@ -142,6 +184,7 @@ bn_mul_mont:
        msgr    $mn0,$n0        # tp[0]*n0
 
        lg      $nlo,0($np)     # np[0]
        msgr    $mn0,$n0        # tp[0]*n0
 
        lg      $nlo,0($np)     # np[0]
+       _dswap  $nlo
        mlgr    $nhi,$mn0       # np[0]*m1
        algr    $nlo,$alo       # +="tp[0]"
        lghi    $NHI,0
        mlgr    $nhi,$mn0       # np[0]*m1
        algr    $nlo,$alo       # +="tp[0]"
        lghi    $NHI,0
@@ -153,14 +196,16 @@ bn_mul_mont:
 .align 16
 .Linner:
        lg      $alo,0($j,$ap)
 .align 16
 .Linner:
        lg      $alo,0($j,$ap)
+       _dswap  $alo
        mlgr    $ahi,$bi        # ap[j]*bp[i]
        algr    $alo,$AHI
        lghi    $AHI,0
        alcgr   $ahi,$AHI
        mlgr    $ahi,$bi        # ap[j]*bp[i]
        algr    $alo,$AHI
        lghi    $AHI,0
        alcgr   $ahi,$AHI
-       alg     $alo,160($j,$sp)# +=tp[j]
+       alg     $alo,$stdframe($j,$sp)# +=tp[j]
        alcgr   $AHI,$ahi
 
        lg      $nlo,0($j,$np)
        alcgr   $AHI,$ahi
 
        lg      $nlo,0($j,$np)
+       _dswap  $nlo
        mlgr    $nhi,$mn0       # np[j]*m1
        algr    $nlo,$NHI
        lghi    $NHI,0
        mlgr    $nhi,$mn0       # np[j]*m1
        algr    $nlo,$NHI
        lghi    $NHI,0
@@ -168,31 +213,33 @@ bn_mul_mont:
        algr    $nlo,$alo       # +="tp[j]"
        alcgr   $NHI,$nhi
 
        algr    $nlo,$alo       # +="tp[j]"
        alcgr   $NHI,$nhi
 
-       stg     $nlo,160-8($j,$sp)      # tp[j-1]=
+       stg     $nlo,$stdframe-8($j,$sp)        # tp[j-1]=
        la      $j,8($j)        # j++
        brct    $count,.Linner
 
        algr    $NHI,$AHI
        lghi    $AHI,0
        alcgr   $AHI,$AHI
        la      $j,8($j)        # j++
        brct    $count,.Linner
 
        algr    $NHI,$AHI
        lghi    $AHI,0
        alcgr   $AHI,$AHI
-       alg     $NHI,160($j,$sp)# accumulate previous upmost overflow bit
+       alg     $NHI,$stdframe($j,$sp)# accumulate previous upmost overflow bit
        lghi    $ahi,0
        alcgr   $AHI,$ahi       # new upmost overflow bit
        lghi    $ahi,0
        alcgr   $AHI,$ahi       # new upmost overflow bit
-       stg     $NHI,160-8($j,$sp)
-       stg     $AHI,160($j,$sp)
+       stg     $NHI,$stdframe-8($j,$sp)
+       stg     $AHI,$stdframe($j,$sp)
 
        la      $bp,8($bp)      # bp++
 
        la      $bp,8($bp)      # bp++
-       clg     $bp,160+8+32($j,$sp)    # compare to &bp[num]
+       cl${g}  $bp,`$stdframe+8+4*$SIZE_T`($j,$sp)     # compare to &bp[num]
        jne     .Louter
 
        jne     .Louter
 
-       lg      $rp,160+8+16($j,$sp)    # reincarnate rp
-       la      $ap,160($sp)
+       l${g}   $rp,`$stdframe+8+2*$SIZE_T`($j,$sp)     # reincarnate rp
+       la      $ap,$stdframe($sp)
        ahi     $num,1          # restore $num, incidentally clears "borrow"
 
        la      $j,0(%r0)
        lr      $count,$num
 .Lsub: lg      $alo,0($j,$ap)
        ahi     $num,1          # restore $num, incidentally clears "borrow"
 
        la      $j,0(%r0)
        lr      $count,$num
 .Lsub: lg      $alo,0($j,$ap)
-       slbg    $alo,0($j,$np)
+       lg      $nlo,0($j,$np)
+       _dswap  $nlo
+       slbgr   $alo,$nlo
        stg     $alo,0($j,$rp)
        la      $j,8($j)
        brct    $count,.Lsub
        stg     $alo,0($j,$rp)
        la      $j,8($j)
        brct    $count,.Lsub
@@ -207,19 +254,24 @@ bn_mul_mont:
 
        la      $j,0(%r0)
        lgr     $count,$num
 
        la      $j,0(%r0)
        lgr     $count,$num
-.Lcopy:        lg      $alo,0($j,$ap)  # copy or in-place refresh
-       stg     $j,160($j,$sp)  # zap tp
+.Lcopy:        lg      $alo,0($j,$ap)          # copy or in-place refresh
+       _dswap  $alo
+       stg     $j,$stdframe($j,$sp)    # zap tp
        stg     $alo,0($j,$rp)
        la      $j,8($j)
        brct    $count,.Lcopy
 
        stg     $alo,0($j,$rp)
        la      $j,8($j)
        brct    $count,.Lcopy
 
-       la      %r1,160+8+48($j,$sp)
-       lmg     %r6,%r15,0(%r1)
+       la      %r1,`$stdframe+8+6*$SIZE_T`($j,$sp)
+       lm${g}  %r6,%r15,0(%r1)
        lghi    %r2,1           # signal "processed"
        br      %r14
 .size  bn_mul_mont,.-bn_mul_mont
 .string        "Montgomery Multiplication for s390x, CRYPTOGAMS by <appro\@openssl.org>"
 ___
 
        lghi    %r2,1           # signal "processed"
        br      %r14
 .size  bn_mul_mont,.-bn_mul_mont
 .string        "Montgomery Multiplication for s390x, CRYPTOGAMS by <appro\@openssl.org>"
 ___
 
-print $code;
+foreach (split("\n",$code)) {
+       s/\`([^\`]*)\`/eval $1/ge;
+       s/_dswap\s+(%r[0-9]+)/sprintf("rllg\t%s,%s,32",$1,$1) if($SIZE_T==4)/e;
+       print $_,"\n";
+}
 close STDOUT;
 close STDOUT;
index c7ed595..1aa7548 100644 (file)
 # "cluster" Address Generation Interlocks, so that one pipeline stall
 # resolves several dependencies.
 
 # "cluster" Address Generation Interlocks, so that one pipeline stall
 # resolves several dependencies.
 
+# November 2010.
+#
+# Adapt for -m31 build. If kernel supports what's called "highgprs"
+# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
+# instructions and achieve "64-bit" performance even in 31-bit legacy
+# application context. The feature is not specific to any particular
+# processor, as long as it's "z-CPU". Latter implies that the code
+# remains z/Architecture specific. On z990 it was measured to perform
+# 50% better than code generated by gcc 4.3.
+
+$flavour = shift;
+
+if ($flavour =~ /3[12]/) {
+       $SIZE_T=4;
+       $g="";
+} else {
+       $SIZE_T=8;
+       $g="g";
+}
+
+while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
+open STDOUT,">$output";
+
 $rp="%r14";
 $sp="%r15";
 $code=<<___;
 $rp="%r14";
 $sp="%r15";
 $code=<<___;
@@ -39,7 +62,12 @@ $code.=<<___;
 .type  RC4,\@function
 .align 64
 RC4:
 .type  RC4,\@function
 .align 64
 RC4:
-       stmg    %r6,%r11,48($sp)
+       stm${g} %r6,%r11,6*$SIZE_T($sp)
+___
+$code.=<<___ if ($flavour =~ /3[12]/);
+       llgfr   $len,$len
+___
+$code.=<<___;
        llgc    $XX[0],0($key)
        llgc    $YY,1($key)
        la      $XX[0],1($XX[0])
        llgc    $XX[0],0($key)
        llgc    $YY,1($key)
        la      $XX[0],1($XX[0])
@@ -90,7 +118,7 @@ $code.=<<___;
        xgr     $acc,$TX[1]
        stg     $acc,0($out)
        la      $out,8($out)
        xgr     $acc,$TX[1]
        stg     $acc,0($out)
        la      $out,8($out)
-       brct    $cnt,.Loop8
+       brctg   $cnt,.Loop8
 
 .Lshort:
        lghi    $acc,7
 
 .Lshort:
        lghi    $acc,7
@@ -122,7 +150,7 @@ $code.=<<___;
        ahi     $XX[0],-1
        stc     $XX[0],0($key)
        stc     $YY,1($key)
        ahi     $XX[0],-1
        stc     $XX[0],0($key)
        stc     $YY,1($key)
-       lmg     %r6,%r11,48($sp)
+       lm${g}  %r6,%r11,6*$SIZE_T($sp)
        br      $rp
 .size  RC4,.-RC4
 .string        "RC4 for s390x, CRYPTOGAMS by <appro\@openssl.org>"
        br      $rp
 .size  RC4,.-RC4
 .string        "RC4 for s390x, CRYPTOGAMS by <appro\@openssl.org>"
@@ -130,7 +158,7 @@ $code.=<<___;
 ___
 }
 
 ___
 }
 
-# void private_RC4_set_key(RC4_KEY *key,unsigned int len,const void *inp)
+# void RC4_set_key(RC4_KEY *key,unsigned int len,const void *inp)
 {
 $cnt="%r0";
 $idx="%r1";
 {
 $cnt="%r0";
 $idx="%r1";
@@ -143,11 +171,11 @@ $ikey="%r7";
 $iinp="%r8";
 
 $code.=<<___;
 $iinp="%r8";
 
 $code.=<<___;
-.globl private_RC4_set_key
-.type  private_RC4_set_key,\@function
+.globl RC4_set_key
+.type  RC4_set_key,\@function
 .align 64
 .align 64
-private_RC4_set_key:
-       stmg    %r6,%r8,48($sp)
+RC4_set_key:
+       stm${g} %r6,%r8,6*$SIZE_T($sp)
        lhi     $cnt,256
        la      $idx,0(%r0)
        sth     $idx,0($key)
        lhi     $cnt,256
        la      $idx,0(%r0)
        sth     $idx,0($key)
@@ -180,9 +208,9 @@ private_RC4_set_key:
        la      $iinp,0(%r0)
        j       .L2ndloop
 .Ldone:
        la      $iinp,0(%r0)
        j       .L2ndloop
 .Ldone:
-       lmg     %r6,%r8,48($sp)
+       lm${g}  %r6,%r8,6*$SIZE_T($sp)
        br      $rp
        br      $rp
-.size  private_RC4_set_key,.-private_RC4_set_key
+.size  RC4_set_key,.-RC4_set_key
 
 ___
 }
 
 ___
 }
@@ -203,3 +231,4 @@ RC4_options:
 ___
 
 print $code;
 ___
 
 print $code;
+close STDOUT;  # force flush
index ffbe023..f2e94ef 100644 (file)
@@ -4,7 +4,7 @@
 #include <setjmp.h>
 #include <signal.h>
 
 #include <setjmp.h>
 #include <signal.h>
 
-extern unsigned long OPENSSL_s390xcap_P;
+extern unsigned long OPENSSL_s390xcap_P[];
 
 static sigjmp_buf ill_jmp;
 static void ill_handler (int sig) { siglongjmp(ill_jmp,sig); }
 
 static sigjmp_buf ill_jmp;
 static void ill_handler (int sig) { siglongjmp(ill_jmp,sig); }
@@ -16,7 +16,9 @@ void OPENSSL_cpuid_setup(void)
        sigset_t oset;
        struct sigaction ill_act,oact;
 
        sigset_t oset;
        struct sigaction ill_act,oact;
 
-       if (OPENSSL_s390xcap_P) return;
+       if (OPENSSL_s390xcap_P[0]) return;
+
+       OPENSSL_s390xcap_P[0] = 1UL<<(8*sizeof(unsigned long)-1);
 
        memset(&ill_act,0,sizeof(ill_act));
        ill_act.sa_handler = ill_handler;
 
        memset(&ill_act,0,sizeof(ill_act));
        ill_act.sa_handler = ill_handler;
@@ -27,10 +29,8 @@ void OPENSSL_cpuid_setup(void)
        sigaction (SIGILL,&ill_act,&oact);
 
        /* protection against missing store-facility-list-extended */
        sigaction (SIGILL,&ill_act,&oact);
 
        /* protection against missing store-facility-list-extended */
-       if (sigsetjmp(ill_jmp,0) == 0)
-               OPENSSL_s390xcap_P = OPENSSL_s390x_facilities();
-       else
-               OPENSSL_s390xcap_P = 1UL<<63;
+       if (sigsetjmp(ill_jmp,1) == 0)
+               OPENSSL_s390x_facilities();
 
        sigaction (SIGILL,&oact,NULL);
        sigprocmask(SIG_SETMASK,&oset,NULL);
 
        sigaction (SIGILL,&oact,NULL);
        sigprocmask(SIG_SETMASK,&oset,NULL);
index b053c6a..0681534 100644 (file)
@@ -5,10 +5,14 @@
 .align 16
 OPENSSL_s390x_facilities:
        lghi    %r0,0
 .align 16
 OPENSSL_s390x_facilities:
        lghi    %r0,0
-       .long   0xb2b0f010      # stfle 16(%r15)
-       lg      %r2,16(%r15)
-       larl    %r1,OPENSSL_s390xcap_P
-       stg     %r2,0(%r1)
+       larl    %r2,OPENSSL_s390xcap_P
+       stg     %r0,8(%r2)
+       .long   0xb2b02000      # stfle 0(%r2)
+       brc     8,.Ldone
+       lghi    %r0,1
+       .long   0xb2b02000      # stfle 0(%r2)
+.Ldone:
+       lg      %r2,0(%r2)
        br      %r14
 .size  OPENSSL_s390x_facilities,.-OPENSSL_s390x_facilities
 
        br      %r14
 .size  OPENSSL_s390x_facilities,.-OPENSSL_s390x_facilities
 
@@ -58,6 +62,9 @@ OPENSSL_wipe_cpu:
 .type  OPENSSL_cleanse,@function
 .align 16
 OPENSSL_cleanse:
 .type  OPENSSL_cleanse,@function
 .align 16
 OPENSSL_cleanse:
+#if !defined(__s390x__) && !defined(__s390x)
+       llgfr   %r3,%r3
+#endif
        lghi    %r4,15
        lghi    %r0,0
        clgr    %r3,%r4
        lghi    %r4,15
        lghi    %r0,0
        clgr    %r3,%r4
@@ -89,4 +96,4 @@ OPENSSL_cleanse:
 .section       .init
        brasl   %r14,OPENSSL_cpuid_setup
 
 .section       .init
        brasl   %r14,OPENSSL_cpuid_setup
 
-.comm  OPENSSL_s390xcap_P,8,8
+.comm  OPENSSL_s390xcap_P,16,8
index 4b17848..9193dda 100644 (file)
 # instructions to favour dual-issue z10 pipeline. On z10 hardware is
 # "only" ~2.3x faster than software.
 
 # instructions to favour dual-issue z10 pipeline. On z10 hardware is
 # "only" ~2.3x faster than software.
 
+# November 2010.
+#
+# Adapt for -m31 build. If kernel supports what's called "highgprs"
+# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
+# instructions and achieve "64-bit" performance even in 31-bit legacy
+# application context. The feature is not specific to any particular
+# processor, as long as it's "z-CPU". Latter implies that the code
+# remains z/Architecture specific.
+
 $kimdfunc=1;   # magic function code for kimd instruction
 
 $kimdfunc=1;   # magic function code for kimd instruction
 
-$output=shift;
+$flavour = shift;
+
+if ($flavour =~ /3[12]/) {
+       $SIZE_T=4;
+       $g="";
+} else {
+       $SIZE_T=8;
+       $g="g";
+}
+
+while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
 open STDOUT,">$output";
 
 $K_00_39="%r0"; $K=$K_00_39;
 open STDOUT,">$output";
 
 $K_00_39="%r0"; $K=$K_00_39;
@@ -42,13 +61,14 @@ $t1="%r11";
 @X=("%r12","%r13","%r14");
 $sp="%r15";
 
 @X=("%r12","%r13","%r14");
 $sp="%r15";
 
-$frame=160+16*4;
+$stdframe=16*$SIZE_T+4*8;
+$frame=$stdframe+16*4;
 
 sub Xupdate {
 my $i=shift;
 
 $code.=<<___ if ($i==15);
 
 sub Xupdate {
 my $i=shift;
 
 $code.=<<___ if ($i==15);
-       lg      $prefetch,160($sp)      ### Xupdate(16) warm-up
+       lg      $prefetch,$stdframe($sp)        ### Xupdate(16) warm-up
        lr      $X[0],$X[2]
 ___
 return if ($i&1);      # Xupdate is vectorized and executed every 2nd cycle
        lr      $X[0],$X[2]
 ___
 return if ($i&1);      # Xupdate is vectorized and executed every 2nd cycle
@@ -58,8 +78,8 @@ $code.=<<___ if ($i<16);
 ___
 $code.=<<___ if ($i>=16);
        xgr     $X[0],$prefetch         ### Xupdate($i)
 ___
 $code.=<<___ if ($i>=16);
        xgr     $X[0],$prefetch         ### Xupdate($i)
-       lg      $prefetch,`160+4*(($i+2)%16)`($sp)
-       xg      $X[0],`160+4*(($i+8)%16)`($sp)
+       lg      $prefetch,`$stdframe+4*(($i+2)%16)`($sp)
+       xg      $X[0],`$stdframe+4*(($i+8)%16)`($sp)
        xgr     $X[0],$prefetch
        rll     $X[0],$X[0],1
        rllg    $X[1],$X[0],32
        xgr     $X[0],$prefetch
        rll     $X[0],$X[0],1
        rllg    $X[1],$X[0],32
@@ -68,7 +88,7 @@ $code.=<<___ if ($i>=16);
        lr      $X[2],$X[1]             # feedback
 ___
 $code.=<<___ if ($i<=70);
        lr      $X[2],$X[1]             # feedback
 ___
 $code.=<<___ if ($i<=70);
-       stg     $X[0],`160+4*($i%16)`($sp)
+       stg     $X[0],`$stdframe+4*($i%16)`($sp)
 ___
 unshift(@X,pop(@X));
 }
 ___
 unshift(@X,pop(@X));
 }
@@ -148,9 +168,9 @@ $code.=<<___ if ($kimdfunc);
        tmhl    %r0,0x4000      # check for message-security assist
        jz      .Lsoftware
        lghi    %r0,0
        tmhl    %r0,0x4000      # check for message-security assist
        jz      .Lsoftware
        lghi    %r0,0
-       la      %r1,16($sp)
+       la      %r1,`2*$SIZE_T`($sp)
        .long   0xb93e0002      # kimd %r0,%r2
        .long   0xb93e0002      # kimd %r0,%r2
-       lg      %r0,16($sp)
+       lg      %r0,`2*$SIZE_T`($sp)
        tmhh    %r0,`0x8000>>$kimdfunc`
        jz      .Lsoftware
        lghi    %r0,$kimdfunc
        tmhh    %r0,`0x8000>>$kimdfunc`
        jz      .Lsoftware
        lghi    %r0,$kimdfunc
@@ -165,11 +185,11 @@ $code.=<<___ if ($kimdfunc);
 ___
 $code.=<<___;
        lghi    %r1,-$frame
 ___
 $code.=<<___;
        lghi    %r1,-$frame
-       stg     $ctx,16($sp)
-       stmg    %r6,%r15,48($sp)
+       st${g}  $ctx,`2*$SIZE_T`($sp)
+       stm${g} %r6,%r15,`6*$SIZE_T`($sp)
        lgr     %r0,$sp
        la      $sp,0(%r1,$sp)
        lgr     %r0,$sp
        la      $sp,0(%r1,$sp)
-       stg     %r0,0($sp)
+       st${g}  %r0,0($sp)
 
        larl    $t0,Ktable
        llgf    $A,0($ctx)
 
        larl    $t0,Ktable
        llgf    $A,0($ctx)
@@ -199,7 +219,7 @@ ___
 for (;$i<80;$i++)      { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 $code.=<<___;
 
 for (;$i<80;$i++)      { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 $code.=<<___;
 
-       lg      $ctx,`$frame+16`($sp)
+       l${g}   $ctx,`$frame+2*$SIZE_T`($sp)
        la      $inp,64($inp)
        al      $A,0($ctx)
        al      $B,4($ctx)
        la      $inp,64($inp)
        al      $A,0($ctx)
        al      $B,4($ctx)
@@ -211,13 +231,13 @@ $code.=<<___;
        st      $C,8($ctx)
        st      $D,12($ctx)
        st      $E,16($ctx)
        st      $C,8($ctx)
        st      $D,12($ctx)
        st      $E,16($ctx)
-       brct    $len,.Lloop
+       brct${g} $len,.Lloop
 
 
-       lmg     %r6,%r15,`$frame+48`($sp)
+       lm${g}  %r6,%r15,`$frame+6*$SIZE_T`($sp)
        br      %r14
 .size  sha1_block_data_order,.-sha1_block_data_order
 .string        "SHA1 block transform for s390x, CRYPTOGAMS by <appro\@openssl.org>"
        br      %r14
 .size  sha1_block_data_order,.-sha1_block_data_order
 .string        "SHA1 block transform for s390x, CRYPTOGAMS by <appro\@openssl.org>"
-.comm  OPENSSL_s390xcap_P,8,8
+.comm  OPENSSL_s390xcap_P,16,8
 ___
 
 $code =~ s/\`([^\`]*)\`/eval $1/gem;
 ___
 
 $code =~ s/\`([^\`]*)\`/eval $1/gem;
index e7ef2d5..079a3fc 100644 (file)
 # favour dual-issue z10 pipeline. Hardware SHA256/512 is ~4.7x faster
 # than software.
 
 # favour dual-issue z10 pipeline. Hardware SHA256/512 is ~4.7x faster
 # than software.
 
+# November 2010.
+#
+# Adapt for -m31 build. If kernel supports what's called "highgprs"
+# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
+# instructions and achieve "64-bit" performance even in 31-bit legacy
+# application context. The feature is not specific to any particular
+# processor, as long as it's "z-CPU". Latter implies that the code
+# remains z/Architecture specific. On z900 SHA256 was measured to
+# perform 2.4x and SHA512 - 13x better than code generated by gcc 4.3.
+
+$flavour = shift;
+
+if ($flavour =~ /3[12]/) {
+       $SIZE_T=4;
+       $g="";
+} else {
+       $SIZE_T=8;
+       $g="g";
+}
+
 $t0="%r0";
 $t1="%r1";
 $ctx="%r2";    $t2="%r2";
 $t0="%r0";
 $t1="%r1";
 $ctx="%r2";    $t2="%r2";
@@ -44,7 +64,7 @@ $tbl="%r13";
 $T1="%r14";
 $sp="%r15";
 
 $T1="%r14";
 $sp="%r15";
 
-$output=shift;
+while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
 open STDOUT,">$output";
 
 if ($output =~ /512/) {
 open STDOUT,">$output";
 
 if ($output =~ /512/) {
@@ -78,7 +98,8 @@ if ($output =~ /512/) {
 }
 $Func="sha${label}_block_data_order";
 $Table="K${label}";
 }
 $Func="sha${label}_block_data_order";
 $Table="K${label}";
-$frame=160+16*$SZ;
+$stdframe=16*$SIZE_T+4*8;
+$frame=$stdframe+16*$SZ;
 
 sub BODY_00_15 {
 my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
 
 sub BODY_00_15 {
 my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
@@ -93,9 +114,9 @@ $code.=<<___;
        xgr     $t0,$t1
        $ROT    $t1,$t1,`$Sigma1[2]-$Sigma1[1]`
         xgr    $t2,$g
        xgr     $t0,$t1
        $ROT    $t1,$t1,`$Sigma1[2]-$Sigma1[1]`
         xgr    $t2,$g
-       $ST     $T1,`160+$SZ*($i%16)`($sp)
+       $ST     $T1,`$stdframe+$SZ*($i%16)`($sp)
        xgr     $t0,$t1                 # Sigma1(e)
        xgr     $t0,$t1                 # Sigma1(e)
-       la      $T1,0($T1,$h)           # T1+=h
+       algr    $T1,$h                  # T1+=h
         ngr    $t2,$e
         lgr    $t1,$a
        algr    $T1,$t0                 # T1+=Sigma1(e)
         ngr    $t2,$e
         lgr    $t1,$a
        algr    $T1,$t0                 # T1+=Sigma1(e)
@@ -113,7 +134,7 @@ $code.=<<___;
         ngr    $t2,$b
        algr    $h,$T1                  # h+=T1
         ogr    $t2,$t1                 # Maj(a,b,c)
         ngr    $t2,$b
        algr    $h,$T1                  # h+=T1
         ogr    $t2,$t1                 # Maj(a,b,c)
-       la      $d,0($d,$T1)            # d+=T1
+       algr    $d,$T1                  # d+=T1
        algr    $h,$t2                  # h+=Maj(a,b,c)
 ___
 }
        algr    $h,$t2                  # h+=Maj(a,b,c)
 ___
 }
@@ -122,19 +143,19 @@ sub BODY_16_XX {
 my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
 
 $code.=<<___;
 my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
 
 $code.=<<___;
-       $LD     $T1,`160+$SZ*(($i+1)%16)`($sp)  ### $i
-       $LD     $t1,`160+$SZ*(($i+14)%16)`($sp)
+       $LD     $T1,`$stdframe+$SZ*(($i+1)%16)`($sp)    ### $i
+       $LD     $t1,`$stdframe+$SZ*(($i+14)%16)`($sp)
        $ROT    $t0,$T1,$sigma0[0]
        $SHR    $T1,$sigma0[2]
        $ROT    $t2,$t0,`$sigma0[1]-$sigma0[0]`
        xgr     $T1,$t0
        $ROT    $t0,$t1,$sigma1[0]
        $ROT    $t0,$T1,$sigma0[0]
        $SHR    $T1,$sigma0[2]
        $ROT    $t2,$t0,`$sigma0[1]-$sigma0[0]`
        xgr     $T1,$t0
        $ROT    $t0,$t1,$sigma1[0]
-       xgr     $T1,$t2                         # sigma0(X[i+1])
+       xgr     $T1,$t2                                 # sigma0(X[i+1])
        $SHR    $t1,$sigma1[2]
        $SHR    $t1,$sigma1[2]
-       $ADD    $T1,`160+$SZ*($i%16)`($sp)      # +=X[i]
+       $ADD    $T1,`$stdframe+$SZ*($i%16)`($sp)        # +=X[i]
        xgr     $t1,$t0
        $ROT    $t0,$t0,`$sigma1[1]-$sigma1[0]`
        xgr     $t1,$t0
        $ROT    $t0,$t0,`$sigma1[1]-$sigma1[0]`
-       $ADD    $T1,`160+$SZ*(($i+9)%16)`($sp)  # +=X[i+9]
+       $ADD    $T1,`$stdframe+$SZ*(($i+9)%16)`($sp)    # +=X[i+9]
        xgr     $t1,$t0                         # sigma1(X[i+14])
        algr    $T1,$t1                         # +=sigma1(X[i+14])
 ___
        xgr     $t1,$t0                         # sigma1(X[i+14])
        algr    $T1,$t1                         # +=sigma1(X[i+14])
 ___
@@ -212,6 +233,7 @@ $code.=<<___;
 .globl $Func
 .type  $Func,\@function
 $Func:
 .globl $Func
 .type  $Func,\@function
 $Func:
+       sllg    $len,$len,`log(16*$SZ)/log(2)`
 ___
 $code.=<<___ if ($kimdfunc);
        larl    %r1,OPENSSL_s390xcap_P
 ___
 $code.=<<___ if ($kimdfunc);
        larl    %r1,OPENSSL_s390xcap_P
@@ -219,15 +241,15 @@ $code.=<<___ if ($kimdfunc);
        tmhl    %r0,0x4000      # check for message-security assist
        jz      .Lsoftware
        lghi    %r0,0
        tmhl    %r0,0x4000      # check for message-security assist
        jz      .Lsoftware
        lghi    %r0,0
-       la      %r1,16($sp)
+       la      %r1,`2*$SIZE_T`($sp)
        .long   0xb93e0002      # kimd %r0,%r2
        .long   0xb93e0002      # kimd %r0,%r2
-       lg      %r0,16($sp)
+       lg      %r0,`2*$SIZE_T`($sp)
        tmhh    %r0,`0x8000>>$kimdfunc`
        jz      .Lsoftware
        lghi    %r0,$kimdfunc
        lgr     %r1,$ctx
        lgr     %r2,$inp
        tmhh    %r0,`0x8000>>$kimdfunc`
        jz      .Lsoftware
        lghi    %r0,$kimdfunc
        lgr     %r1,$ctx
        lgr     %r2,$inp
-       sllg    %r3,$len,`log(16*$SZ)/log(2)`
+       lgr     %r3,$len
        .long   0xb93e0002      # kimd %r0,%r2
        brc     1,.-4           # pay attention to "partial completion"
        br      %r14
        .long   0xb93e0002      # kimd %r0,%r2
        brc     1,.-4           # pay attention to "partial completion"
        br      %r14
@@ -235,13 +257,12 @@ $code.=<<___ if ($kimdfunc);
 .Lsoftware:
 ___
 $code.=<<___;
 .Lsoftware:
 ___
 $code.=<<___;
-       sllg    $len,$len,`log(16*$SZ)/log(2)`
        lghi    %r1,-$frame
        lghi    %r1,-$frame
-       agr     $len,$inp
-       stmg    $ctx,%r15,16($sp)
+       la      $len,0($len,$inp)
+       stm${g} $ctx,%r15,`2*$SIZE_T`($sp)
        lgr     %r0,$sp
        la      $sp,0(%r1,$sp)
        lgr     %r0,$sp
        la      $sp,0(%r1,$sp)
-       stg     %r0,0($sp)
+       st${g}  %r0,0($sp)
 
        larl    $tbl,$Table
        $LD     $A,`0*$SZ`($ctx)
 
        larl    $tbl,$Table
        $LD     $A,`0*$SZ`($ctx)
@@ -265,7 +286,7 @@ $code.=<<___;
        clgr    $len,$t0
        jne     .Lrounds_16_xx
 
        clgr    $len,$t0
        jne     .Lrounds_16_xx
 
-       lg      $ctx,`$frame+16`($sp)
+       l${g}   $ctx,`$frame+2*$SIZE_T`($sp)
        la      $inp,`16*$SZ`($inp)
        $ADD    $A,`0*$SZ`($ctx)
        $ADD    $B,`1*$SZ`($ctx)
        la      $inp,`16*$SZ`($inp)
        $ADD    $A,`0*$SZ`($ctx)
        $ADD    $B,`1*$SZ`($ctx)
@@ -283,14 +304,14 @@ $code.=<<___;
        $ST     $F,`5*$SZ`($ctx)
        $ST     $G,`6*$SZ`($ctx)
        $ST     $H,`7*$SZ`($ctx)
        $ST     $F,`5*$SZ`($ctx)
        $ST     $G,`6*$SZ`($ctx)
        $ST     $H,`7*$SZ`($ctx)
-       clg     $inp,`$frame+32`($sp)
+       cl${g}  $inp,`$frame+4*$SIZE_T`($sp)
        jne     .Lloop
 
        jne     .Lloop
 
-       lmg     %r6,%r15,`$frame+48`($sp)       
+       lm${g}  %r6,%r15,`$frame+6*$SIZE_T`($sp)        
        br      %r14
 .size  $Func,.-$Func
 .string        "SHA${label} block transform for s390x, CRYPTOGAMS by <appro\@openssl.org>"
        br      %r14
 .size  $Func,.-$Func
 .string        "SHA${label} block transform for s390x, CRYPTOGAMS by <appro\@openssl.org>"
-.comm  OPENSSL_s390xcap_P,8,8
+.comm  OPENSSL_s390xcap_P,16,8
 ___
 
 $code =~ s/\`([^\`]*)\`/eval $1/gem;
 ___
 
 $code =~ s/\`([^\`]*)\`/eval $1/gem;