crypto/sha/asm/sha512-ia64.pl

   1 #!/usr/bin/env perl
   2 #
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@openssl.org> for the OpenSSL
   5 # project. The module is, however, dual licensed under OpenSSL and
   6 # CRYPTOGAMS licenses depending on where you obtain it. For further
   7 # details see http://www.openssl.org/~appro/cryptogams/.
   8 # ====================================================================
   9 #
  10 # SHA256/512_Transform for Itanium.
  11 #
  12 # sha512_block runs in 1003 cycles on Itanium 2, which is almost 50%
  13 # faster than gcc and >60%(!) faster than code generated by HP-UX
  14 # compiler (yes, HP-UX is generating slower code, because unlike gcc,
  15 # it failed to deploy "shift right pair," 'shrp' instruction, which
  16 # substitutes for 64-bit rotate).
  17 #
  18 # 924 cycles long sha256_block outperforms gcc by over factor of 2(!)
  19 # and HP-UX compiler - by >40% (yes, gcc won sha512_block, but lost
  20 # this one big time). Note that "formally" 924 is about 100 cycles
  21 # too much. I mean it's 64 32-bit rounds vs. 80 virtually identical
  22 # 64-bit ones and 1003*64/80 gives 802. Extra cycles, 2 per round,
  23 # are spent on extra work to provide for 32-bit rotations. 32-bit
  24 # rotations are still handled by 'shrp' instruction and for this
  25 # reason lower 32 bits are deposited to upper half of 64-bit register
  26 # prior 'shrp' issue. And in order to minimize the amount of such
  27 # operations, X[16] values are *maintained* with copies of lower
  28 # halves in upper halves, which is why you'll spot such instructions
  29 # as custom 'mux2', "parallel 32-bit add," 'padd4' and "parallel
  30 # 32-bit unsigned right shift," 'pshr4.u' instructions here.
  31 #
  32 # Rules of engagement.
  33 #
  34 # There is only one integer shifter meaning that if I have two rotate,
  35 # deposit or extract instructions in adjacent bundles, they shall
  36 # split [at run-time if they have to]. But note that variable and
  37 # parallel shifts are performed by multi-media ALU and *are* pairable
  38 # with rotates [and alike]. On the backside MMALU is rather slow: it
  39 # takes 2 extra cycles before the result of integer operation is
  40 # available *to* MMALU and 2(*) extra cycles before the result of MM
  41 # operation is available "back" *to* integer ALU, not to mention that
  42 # MMALU itself has 2 cycles latency. However! I explicitly scheduled
  43 # these MM instructions to avoid MM stalls, so that all these extra
  44 # latencies get "hidden" in instruction-level parallelism.
  45 #
  46 # (*) 2 cycles on Itanium 1 and 1 cycle on Itanium 2. But I schedule
  47 #     for 2 in order to provide for best *overall* performance,
  48 #     because on Itanium 1 stall on MM result is accompanied by
  49 #     pipeline flush, which takes 6 cycles:-(
  50 #
  51 # June 2012
  52 #
  53 # Improve performance by 15-20%. Note about "rules of engagement"
  54 # above. Contemporary cores are equipped with additional shifter,
  55 # so that they should perform even better than below, presumably
  56 # by ~10%.
  57 #
  58 ######################################################################
  59 # Current performance in cycles per processed byte for Itanium 2
  60 # pre-9000 series [little-endian] system:
  61 #
  62 # SHA1(*)       5.7
  63 # SHA256        12.6
  64 # SHA512        6.7
  65 #
  66 # (*) SHA1 result is presented purely for reference purposes.
  67 #
  68 # To generate code, pass the file name with either 256 or 512 in its
  69 # name and compiler flags.
  70
  71 $output=shift;
  72
  73 if ($output =~ /512.*\.[s|asm]/) {
  74         $SZ=8;
  75         $BITS=8*$SZ;
  76         $LDW="ld8";
  77         $STW="st8";
  78         $ADD="add";
  79         $SHRU="shr.u";
  80         $TABLE="K512";
  81         $func="sha512_block_data_order";
  82         @Sigma0=(28,34,39);
  83         @Sigma1=(14,18,41);
  84         @sigma0=(1,  8, 7);
  85         @sigma1=(19,61, 6);
  86         $rounds=80;
  87 } elsif ($output =~ /256.*\.[s|asm]/) {
  88         $SZ=4;
  89         $BITS=8*$SZ;
  90         $LDW="ld4";
  91         $STW="st4";
  92         $ADD="padd4";
  93         $SHRU="pshr4.u";
  94         $TABLE="K256";
  95         $func="sha256_block_data_order";
  96         @Sigma0=( 2,13,22);
  97         @Sigma1=( 6,11,25);
  98         @sigma0=( 7,18, 3);
  99         @sigma1=(17,19,10);
 100         $rounds=64;
 101 } else { die "nonsense $output"; }
 102
 103 open STDOUT,">$output" || die "can't open $output: $!";
 104
 105 if ($^O eq "hpux") {
 106     $ADDP="addp4";
 107     for (@ARGV) { $ADDP="add" if (/[\+DD|\-mlp]64/); }
 108 } else { $ADDP="add"; }
 109 for (@ARGV)  {  $big_endian=1 if (/\-DB_ENDIAN/);
 110                 $big_endian=0 if (/\-DL_ENDIAN/);  }
 111 if (!defined($big_endian))
 112              {  $big_endian=(unpack('L',pack('N',1))==1);  }
 113
 114 $code=<<___;
 115 .ident  \"$output, version 2.0\"
 116 .ident  \"IA-64 ISA artwork by Andy Polyakov <appro\@openssl.org>\"
 117 .explicit
 118 .text
 119
 120 pfssave=r2;
 121 lcsave=r3;
 122 prsave=r14;
 123 K=r15;
 124 A_=r16; B_=r17; C_=r18; D_=r19;
 125 E_=r20; F_=r21; G_=r22; H_=r23;
 126 T1=r24; T2=r25;
 127 s0=r26; s1=r27; t0=r28; t1=r29;
 128 Ktbl=r30;
 129 ctx=r31;        // 1st arg
 130 input=r56;      // 2nd arg
 131 num=r57;        // 3rd arg
 132 sgm0=r58;       sgm1=r59;       // small constants
 133
 134 // void $func (SHA_CTX *ctx, const void *in,size_t num[,int host])
 135 .global $func#
 136 .proc   $func#
 137 .align  32
 138 .skip   16
 139 $func:
 140         .prologue
 141         .save   ar.pfs,pfssave
 142 { .mmi; alloc   pfssave=ar.pfs,3,25,0,24
 143         $ADDP   ctx=0,r32               // 1st arg
 144         .save   ar.lc,lcsave
 145         mov     lcsave=ar.lc    }
 146 { .mmi; $ADDP   input=0,r33             // 2nd arg
 147         mov     num=r34                 // 3rd arg
 148         .save   pr,prsave
 149         mov     prsave=pr       };;
 150
 151         .body
 152 { .mib; add     r8=0*$SZ,ctx
 153         add     r9=1*$SZ,ctx    }
 154 { .mib; add     r10=2*$SZ,ctx
 155         add     r11=3*$SZ,ctx   };;
 156
 157 // load A-H
 158 .Lpic_point:
 159 { .mmi; $LDW    A_=[r8],4*$SZ
 160         $LDW    B_=[r9],4*$SZ
 161         mov     Ktbl=ip         }
 162 { .mmi; $LDW    C_=[r10],4*$SZ
 163         $LDW    D_=[r11],4*$SZ
 164         mov     sgm0=$sigma0[2] };;
 165 { .mmi; $LDW    E_=[r8]
 166         $LDW    F_=[r9]
 167         add     Ktbl=($TABLE#-.Lpic_point),Ktbl         }
 168 { .mmi; $LDW    G_=[r10]
 169         $LDW    H_=[r11]
 170         cmp.ne  p0,p16=0,r0     };;
 171 ___
 172 $code.=<<___ if ($BITS==64);
 173 { .mii; and     r8=7,input
 174         and     input=~7,input;;
 175         cmp.eq  p9,p0=1,r8      }
 176 { .mmi; cmp.eq  p10,p0=2,r8
 177         cmp.eq  p11,p0=3,r8
 178         cmp.eq  p12,p0=4,r8     }
 179 { .mmi; cmp.eq  p13,p0=5,r8
 180         cmp.eq  p14,p0=6,r8
 181         cmp.eq  p15,p0=7,r8     };;
 182 ___
 183 $code.=<<___;
 184 .L_outer:
 185 .rotr   R[8],X[16]
 186 A=R[0]; B=R[1]; C=R[2]; D=R[3]; E=R[4]; F=R[5]; G=R[6]; H=R[7]
 187 { .mmi; ld1     X[15]=[input],$SZ               // eliminated in sha512
 188         mov     A=A_
 189         mov     ar.lc=14        }
 190 { .mmi; mov     B=B_
 191         mov     C=C_
 192         mov     D=D_            }
 193 { .mmi; mov     E=E_
 194         mov     F=F_
 195         mov     ar.ec=2         };;
 196 { .mmi; mov     G=G_
 197         mov     H=H_
 198         mov     sgm1=$sigma1[2] }
 199 { .mib; mov     r8=0
 200         add     r9=1-$SZ,input
 201         brp.loop.imp    .L_first16,.L_first16_end-16    };;
 202 ___
 203 $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
 204 // in sha512 case I load whole X[16] at once and take care of alignment...
 205 { .mmi; add     r8=1*$SZ,input
 206         add     r9=2*$SZ,input
 207         add     r10=3*$SZ,input         };;
 208 { .mmb; $LDW    X[15]=[input],4*$SZ
 209         $LDW    X[14]=[r8],4*$SZ
 210 (p9)    br.cond.dpnt.many       .L1byte };;
 211 { .mmb; $LDW    X[13]=[r9],4*$SZ
 212         $LDW    X[12]=[r10],4*$SZ
 213 (p10)   br.cond.dpnt.many       .L2byte };;
 214 { .mmb; $LDW    X[11]=[input],4*$SZ
 215         $LDW    X[10]=[r8],4*$SZ
 216 (p11)   br.cond.dpnt.many       .L3byte };;
 217 { .mmb; $LDW    X[ 9]=[r9],4*$SZ
 218         $LDW    X[ 8]=[r10],4*$SZ
 219 (p12)   br.cond.dpnt.many       .L4byte };;
 220 { .mmb; $LDW    X[ 7]=[input],4*$SZ
 221         $LDW    X[ 6]=[r8],4*$SZ
 222 (p13)   br.cond.dpnt.many       .L5byte };;
 223 { .mmb; $LDW    X[ 5]=[r9],4*$SZ
 224         $LDW    X[ 4]=[r10],4*$SZ
 225 (p14)   br.cond.dpnt.many       .L6byte };;
 226 { .mmb; $LDW    X[ 3]=[input],4*$SZ
 227         $LDW    X[ 2]=[r8],4*$SZ
 228 (p15)   br.cond.dpnt.many       .L7byte };;
 229 { .mmb; $LDW    X[ 1]=[r9],4*$SZ
 230         $LDW    X[ 0]=[r10],4*$SZ       }
 231 { .mib; mov     r8=0
 232         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 233         br.many .L_first16              };;
 234 .L1byte:
 235 { .mmi; $LDW    X[13]=[r9],4*$SZ
 236         $LDW    X[12]=[r10],4*$SZ
 237         shrp    X[15]=X[15],X[14],56    };;
 238 { .mmi; $LDW    X[11]=[input],4*$SZ
 239         $LDW    X[10]=[r8],4*$SZ
 240         shrp    X[14]=X[14],X[13],56    }
 241 { .mmi; $LDW    X[ 9]=[r9],4*$SZ
 242         $LDW    X[ 8]=[r10],4*$SZ
 243         shrp    X[13]=X[13],X[12],56    };;
 244 { .mmi; $LDW    X[ 7]=[input],4*$SZ
 245         $LDW    X[ 6]=[r8],4*$SZ
 246         shrp    X[12]=X[12],X[11],56    }
 247 { .mmi; $LDW    X[ 5]=[r9],4*$SZ
 248         $LDW    X[ 4]=[r10],4*$SZ
 249         shrp    X[11]=X[11],X[10],56    };;
 250 { .mmi; $LDW    X[ 3]=[input],4*$SZ
 251         $LDW    X[ 2]=[r8],4*$SZ
 252         shrp    X[10]=X[10],X[ 9],56    }
 253 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 254         $LDW    X[ 0]=[r10],4*$SZ
 255         shrp    X[ 9]=X[ 9],X[ 8],56    };;
 256 { .mii; $LDW    T1=[input]
 257         shrp    X[ 8]=X[ 8],X[ 7],56
 258         shrp    X[ 7]=X[ 7],X[ 6],56    }
 259 { .mii; shrp    X[ 6]=X[ 6],X[ 5],56
 260         shrp    X[ 5]=X[ 5],X[ 4],56    };;
 261 { .mii; shrp    X[ 4]=X[ 4],X[ 3],56
 262         shrp    X[ 3]=X[ 3],X[ 2],56    }
 263 { .mii; shrp    X[ 2]=X[ 2],X[ 1],56
 264         shrp    X[ 1]=X[ 1],X[ 0],56    }
 265 { .mib; shrp    X[ 0]=X[ 0],T1,56       }
 266 { .mib; mov     r8=0
 267         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 268         br.many .L_first16              };;
 269 .L2byte:
 270 { .mmi; $LDW    X[11]=[input],4*$SZ
 271         $LDW    X[10]=[r8],4*$SZ
 272         shrp    X[15]=X[15],X[14],48    }
 273 { .mmi; $LDW    X[ 9]=[r9],4*$SZ
 274         $LDW    X[ 8]=[r10],4*$SZ
 275         shrp    X[14]=X[14],X[13],48    };;
 276 { .mmi; $LDW    X[ 7]=[input],4*$SZ
 277         $LDW    X[ 6]=[r8],4*$SZ
 278         shrp    X[13]=X[13],X[12],48    }
 279 { .mmi; $LDW    X[ 5]=[r9],4*$SZ
 280         $LDW    X[ 4]=[r10],4*$SZ
 281         shrp    X[12]=X[12],X[11],48    };;
 282 { .mmi; $LDW    X[ 3]=[input],4*$SZ
 283         $LDW    X[ 2]=[r8],4*$SZ
 284         shrp    X[11]=X[11],X[10],48    }
 285 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 286         $LDW    X[ 0]=[r10],4*$SZ
 287         shrp    X[10]=X[10],X[ 9],48    };;
 288 { .mii; $LDW    T1=[input]
 289         shrp    X[ 9]=X[ 9],X[ 8],48
 290         shrp    X[ 8]=X[ 8],X[ 7],48    }
 291 { .mii; shrp    X[ 7]=X[ 7],X[ 6],48
 292         shrp    X[ 6]=X[ 6],X[ 5],48    };;
 293 { .mii; shrp    X[ 5]=X[ 5],X[ 4],48
 294         shrp    X[ 4]=X[ 4],X[ 3],48    }
 295 { .mii; shrp    X[ 3]=X[ 3],X[ 2],48
 296         shrp    X[ 2]=X[ 2],X[ 1],48    }
 297 { .mii; shrp    X[ 1]=X[ 1],X[ 0],48
 298         shrp    X[ 0]=X[ 0],T1,48       }
 299 { .mib; mov     r8=0
 300         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 301         br.many .L_first16              };;
 302 .L3byte:
 303 { .mmi; $LDW    X[ 9]=[r9],4*$SZ
 304         $LDW    X[ 8]=[r10],4*$SZ
 305         shrp    X[15]=X[15],X[14],40    };;
 306 { .mmi; $LDW    X[ 7]=[input],4*$SZ
 307         $LDW    X[ 6]=[r8],4*$SZ
 308         shrp    X[14]=X[14],X[13],40    }
 309 { .mmi; $LDW    X[ 5]=[r9],4*$SZ
 310         $LDW    X[ 4]=[r10],4*$SZ
 311         shrp    X[13]=X[13],X[12],40    };;
 312 { .mmi; $LDW    X[ 3]=[input],4*$SZ
 313         $LDW    X[ 2]=[r8],4*$SZ
 314         shrp    X[12]=X[12],X[11],40    }
 315 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 316         $LDW    X[ 0]=[r10],4*$SZ
 317         shrp    X[11]=X[11],X[10],40    };;
 318 { .mii; $LDW    T1=[input]
 319         shrp    X[10]=X[10],X[ 9],40
 320         shrp    X[ 9]=X[ 9],X[ 8],40    }
 321 { .mii; shrp    X[ 8]=X[ 8],X[ 7],40
 322         shrp    X[ 7]=X[ 7],X[ 6],40    };;
 323 { .mii; shrp    X[ 6]=X[ 6],X[ 5],40
 324         shrp    X[ 5]=X[ 5],X[ 4],40    }
 325 { .mii; shrp    X[ 4]=X[ 4],X[ 3],40
 326         shrp    X[ 3]=X[ 3],X[ 2],40    }
 327 { .mii; shrp    X[ 2]=X[ 2],X[ 1],40
 328         shrp    X[ 1]=X[ 1],X[ 0],40    }
 329 { .mib; shrp    X[ 0]=X[ 0],T1,40       }
 330 { .mib; mov     r8=0
 331         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 332         br.many .L_first16              };;
 333 .L4byte:
 334 { .mmi; $LDW    X[ 7]=[input],4*$SZ
 335         $LDW    X[ 6]=[r8],4*$SZ
 336         shrp    X[15]=X[15],X[14],32    }
 337 { .mmi; $LDW    X[ 5]=[r9],4*$SZ
 338         $LDW    X[ 4]=[r10],4*$SZ
 339         shrp    X[14]=X[14],X[13],32    };;
 340 { .mmi; $LDW    X[ 3]=[input],4*$SZ
 341         $LDW    X[ 2]=[r8],4*$SZ
 342         shrp    X[13]=X[13],X[12],32    }
 343 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 344         $LDW    X[ 0]=[r10],4*$SZ
 345         shrp    X[12]=X[12],X[11],32    };;
 346 { .mii; $LDW    T1=[input]
 347         shrp    X[11]=X[11],X[10],32
 348         shrp    X[10]=X[10],X[ 9],32    }
 349 { .mii; shrp    X[ 9]=X[ 9],X[ 8],32
 350         shrp    X[ 8]=X[ 8],X[ 7],32    };;
 351 { .mii; shrp    X[ 7]=X[ 7],X[ 6],32
 352         shrp    X[ 6]=X[ 6],X[ 5],32    }
 353 { .mii; shrp    X[ 5]=X[ 5],X[ 4],32
 354         shrp    X[ 4]=X[ 4],X[ 3],32    }
 355 { .mii; shrp    X[ 3]=X[ 3],X[ 2],32
 356         shrp    X[ 2]=X[ 2],X[ 1],32    }
 357 { .mii; shrp    X[ 1]=X[ 1],X[ 0],32
 358         shrp    X[ 0]=X[ 0],T1,32       }
 359 { .mib; mov     r8=0
 360         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 361         br.many .L_first16              };;
 362 .L5byte:
 363 { .mmi; $LDW    X[ 5]=[r9],4*$SZ
 364         $LDW    X[ 4]=[r10],4*$SZ
 365         shrp    X[15]=X[15],X[14],24    };;
 366 { .mmi; $LDW    X[ 3]=[input],4*$SZ
 367         $LDW    X[ 2]=[r8],4*$SZ
 368         shrp    X[14]=X[14],X[13],24    }
 369 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 370         $LDW    X[ 0]=[r10],4*$SZ
 371         shrp    X[13]=X[13],X[12],24    };;
 372 { .mii; $LDW    T1=[input]
 373         shrp    X[12]=X[12],X[11],24
 374         shrp    X[11]=X[11],X[10],24    }
 375 { .mii; shrp    X[10]=X[10],X[ 9],24
 376         shrp    X[ 9]=X[ 9],X[ 8],24    };;
 377 { .mii; shrp    X[ 8]=X[ 8],X[ 7],24
 378         shrp    X[ 7]=X[ 7],X[ 6],24    }
 379 { .mii; shrp    X[ 6]=X[ 6],X[ 5],24
 380         shrp    X[ 5]=X[ 5],X[ 4],24    }
 381 { .mii; shrp    X[ 4]=X[ 4],X[ 3],24
 382         shrp    X[ 3]=X[ 3],X[ 2],24    }
 383 { .mii; shrp    X[ 2]=X[ 2],X[ 1],24
 384         shrp    X[ 1]=X[ 1],X[ 0],24    }
 385 { .mib; shrp    X[ 0]=X[ 0],T1,24       }
 386 { .mib; mov     r8=0
 387         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 388         br.many .L_first16              };;
 389 .L6byte:
 390 { .mmi; $LDW    X[ 3]=[input],4*$SZ
 391         $LDW    X[ 2]=[r8],4*$SZ
 392         shrp    X[15]=X[15],X[14],16    }
 393 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 394         $LDW    X[ 0]=[r10],4*$SZ
 395         shrp    X[14]=X[14],X[13],16    };;
 396 { .mii; $LDW    T1=[input]
 397         shrp    X[13]=X[13],X[12],16
 398         shrp    X[12]=X[12],X[11],16    }
 399 { .mii; shrp    X[11]=X[11],X[10],16
 400         shrp    X[10]=X[10],X[ 9],16    };;
 401 { .mii; shrp    X[ 9]=X[ 9],X[ 8],16
 402         shrp    X[ 8]=X[ 8],X[ 7],16    }
 403 { .mii; shrp    X[ 7]=X[ 7],X[ 6],16
 404         shrp    X[ 6]=X[ 6],X[ 5],16    }
 405 { .mii; shrp    X[ 5]=X[ 5],X[ 4],16
 406         shrp    X[ 4]=X[ 4],X[ 3],16    }
 407 { .mii; shrp    X[ 3]=X[ 3],X[ 2],16
 408         shrp    X[ 2]=X[ 2],X[ 1],16    }
 409 { .mii; shrp    X[ 1]=X[ 1],X[ 0],16
 410         shrp    X[ 0]=X[ 0],T1,16       }
 411 { .mib; mov     r8=0
 412         mux1    X[15]=X[15],\@rev               // eliminated on big-endian
 413         br.many .L_first16              };;
 414 .L7byte:
 415 { .mmi; $LDW    X[ 1]=[r9],4*$SZ
 416         $LDW    X[ 0]=[r10],4*$SZ
 417         shrp    X[15]=X[15],X[14],8     };;
 418 { .mii; $LDW    T1=[input]
 419         shrp    X[14]=X[14],X[13],8
 420         shrp    X[13]=X[13],X[12],8     }
 421 { .mii; shrp    X[12]=X[12],X[11],8
 422         shrp    X[11]=X[11],X[10],8     };;
 423 { .mii; shrp    X[10]=X[10],X[ 9],8
 424         shrp    X[ 9]=X[ 9],X[ 8],8     }
 425 { .mii; shrp    X[ 8]=X[ 8],X[ 7],8
 426         shrp    X[ 7]=X[ 7],X[ 6],8     }
 427 { .mii; shrp    X[ 6]=X[ 6],X[ 5],8
 428         shrp    X[ 5]=X[ 5],X[ 4],8     }
 429 { .mii; shrp    X[ 4]=X[ 4],X[ 3],8
 430         shrp    X[ 3]=X[ 3],X[ 2],8     }
 431 { .mii; shrp    X[ 2]=X[ 2],X[ 1],8
 432         shrp    X[ 1]=X[ 1],X[ 0],8     }
 433 { .mib; shrp    X[ 0]=X[ 0],T1,8        }
 434 { .mib; mov     r8=0
 435         mux1    X[15]=X[15],\@rev       };;     // eliminated on big-endian
 436
 437 .align  32
 438 .L_first16:
 439 { .mmi;         $LDW    K=[Ktbl],$SZ
 440                 add     A=A,r8                  // H+=Sigma(0) from the past
 441                 _rotr   r10=$t1,$Sigma1[0]  }   // ROTR(e,14)
 442 { .mmi;         and     T1=F,E
 443                 andcm   r8=G,E
 444         (p16)   mux1    X[14]=X[14],\@rev   };; // eliminated on big-endian
 445 { .mmi;         and     T2=A,B
 446                 and     r9=A,C
 447                 _rotr   r11=$t1,$Sigma1[1]  }   // ROTR(e,41)
 448 { .mmi;         xor     T1=T1,r8                // T1=((e & f) ^ (~e & g))
 449                 and     r8=B,C              };;
 450 ___
 451 $t0="t0", $t1="t1", $code.=<<___ if ($BITS==32);
 452 .align  32
 453 .L_first16:
 454 { .mmi;         add     A=A,r8                  // H+=Sigma(0) from the past
 455                 add     r10=2-$SZ,input
 456                 add     r11=3-$SZ,input };;
 457 { .mmi;         ld1     r9=[r9]
 458                 ld1     r10=[r10]
 459                 dep.z   $t1=E,32,32     }
 460 { .mmi;         ld1     r11=[r11]
 461                 $LDW    K=[Ktbl],$SZ
 462                 zxt4    E=E             };;
 463 { .mii;         or      $t1=$t1,E
 464                 dep     X[15]=X[15],r9,8,8
 465                 mux2    $t0=A,0x44      };;     // copy lower half to upper
 466 { .mmi;         and     T1=F,E
 467                 andcm   r8=G,E
 468                 dep     r11=r10,r11,8,8 };;
 469 { .mmi;         and     T2=A,B
 470                 and     r9=A,C
 471                 dep     X[15]=X[15],r11,16,16   };;
 472 { .mmi; (p16)   ld1     X[15-1]=[input],$SZ     // prefetch
 473                 xor     T1=T1,r8                // T1=((e & f) ^ (~e & g))
 474                 _rotr   r10=$t1,$Sigma1[0] }    // ROTR(e,14)
 475 { .mmi;         and     r8=B,C
 476                 _rotr   r11=$t1,$Sigma1[1] };;  // ROTR(e,18)
 477 ___
 478 $code.=<<___;
 479 { .mmi;         add     T1=T1,H                 // T1=Ch(e,f,g)+h
 480                 xor     r10=r10,r11
 481                 _rotr   r11=$t1,$Sigma1[2]  }   // ROTR(e,41)
 482 { .mmi;         xor     T2=T2,r9
 483                 add     K=K,X[15]           };;
 484 { .mmi;         add     T1=T1,K                 // T1+=K[i]+X[i]
 485                 xor     T2=T2,r8                // T2=((a & b) ^ (a & c) ^ (b & c))
 486                 _rotr   r8=$t0,$Sigma0[0]   }   // ROTR(a,28)
 487 { .mmi;         xor     r11=r11,r10             // Sigma1(e)
 488                 _rotr   r9=$t0,$Sigma0[1]   };; // ROTR(a,34)
 489 { .mmi;         add     T1=T1,r11               // T+=Sigma1(e)
 490                 xor     r8=r8,r9
 491                 _rotr   r9=$t0,$Sigma0[2]   };; // ROTR(a,39)
 492 { .mmi;         xor     r8=r8,r9                // Sigma0(a)
 493                 add     D=D,T1
 494                 mux2    H=X[15],0x44        }   // mov H=X[15] in sha512
 495 { .mib; (p16)   add     r9=1-$SZ,input          // not used in sha512
 496                 add     X[15]=T1,T2             // H=T1+Maj(a,b,c)
 497         br.ctop.sptk    .L_first16          };;
 498 .L_first16_end:
 499
 500 { .mib; mov     ar.lc=$rounds-17
 501         brp.loop.imp    .L_rest,.L_rest_end-16          }
 502 { .mib; mov     ar.ec=1
 503         br.many .L_rest                 };;
 504
 505 .align  32
 506 .L_rest:
 507 { .mmi;         $LDW    K=[Ktbl],$SZ
 508                 add     A=A,r8                  // H+=Sigma0(a) from the past
 509                 _rotr   r8=X[15-1],$sigma0[0] } // ROTR(s0,1)
 510 { .mmi;         add     X[15]=X[15],X[15-9]     // X[i&0xF]+=X[(i+9)&0xF]
 511                 $SHRU   s0=X[15-1],sgm0     };; // s0=X[(i+1)&0xF]>>7
 512 { .mib;         and     T1=F,E
 513                 _rotr   r9=X[15-1],$sigma0[1] } // ROTR(s0,8)
 514 { .mib;         andcm   r10=G,E
 515                 $SHRU   s1=X[15-14],sgm1    };; // s1=X[(i+14)&0xF]>>6
 516 // Pair of mmi; splits on Itanium 1 and prevents pipeline flush
 517 // upon $SHRU output usage
 518 { .mmi;         xor     T1=T1,r10               // T1=((e & f) ^ (~e & g))
 519                 xor     r9=r8,r9
 520                 _rotr   r10=X[15-14],$sigma1[0] }// ROTR(s1,19)
 521 { .mmi;         and     T2=A,B
 522                 and     r8=A,C
 523                 _rotr   r11=X[15-14],$sigma1[1] };;// ROTR(s1,61)
 524 ___
 525 $t0="t0", $t1="t1", $code.=<<___ if ($BITS==32);
 526 { .mib;         xor     s0=s0,r9                // s0=sigma0(X[(i+1)&0xF])
 527                 dep.z   $t1=E,32,32         }
 528 { .mib;         xor     r10=r11,r10
 529                 zxt4    E=E                 };;
 530 { .mii;         xor     s1=s1,r10               // s1=sigma1(X[(i+14)&0xF])
 531                 shrp    r9=E,$t1,32+$Sigma1[0]  // ROTR(e,14)
 532                 mux2    $t0=A,0x44          };; // copy lower half to upper
 533 // Pair of mmi; splits on Itanium 1 and prevents pipeline flush
 534 // upon mux2 output usage
 535 { .mmi;         xor     T2=T2,r8
 536                 shrp    r8=E,$t1,32+$Sigma1[1]} // ROTR(e,18)
 537 { .mmi;         and     r10=B,C
 538                 add     T1=T1,H                 // T1=Ch(e,f,g)+h
 539                 or      $t1=$t1,E           };;
 540 ___
 541 $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
 542 { .mib;         xor     s0=s0,r9                // s0=sigma0(X[(i+1)&0xF])
 543                 _rotr   r9=$t1,$Sigma1[0]   }   // ROTR(e,14)
 544 { .mib;         xor     r10=r11,r10
 545                 xor     T2=T2,r8            };;
 546 { .mib;         xor     s1=s1,r10               // s1=sigma1(X[(i+14)&0xF])
 547                 _rotr   r8=$t1,$Sigma1[1]   }   // ROTR(e,18)
 548 { .mib;         and     r10=B,C
 549                 add     T1=T1,H             };; // T1+=H
 550 ___
 551 $code.=<<___;
 552 { .mib;         xor     r9=r9,r8
 553                 _rotr   r8=$t1,$Sigma1[2]   }   // ROTR(e,41)
 554 { .mib;         xor     T2=T2,r10               // T2=((a & b) ^ (a & c) ^ (b & c))
 555                 add     X[15]=X[15],s0      };; // X[i]+=sigma0(X[i+1])
 556 { .mmi;         xor     r9=r9,r8                // Sigma1(e)
 557                 add     X[15]=X[15],s1          // X[i]+=sigma0(X[i+14])
 558                 _rotr   r8=$t0,$Sigma0[0]   };; // ROTR(a,28)
 559 { .mmi;         add     K=K,X[15]
 560                 add     T1=T1,r9                // T1+=Sigma1(e)
 561                 _rotr   r9=$t0,$Sigma0[1]   };; // ROTR(a,34)
 562 { .mmi;         add     T1=T1,K                 // T1+=K[i]+X[i]
 563                 xor     r8=r8,r9
 564                 _rotr   r9=$t0,$Sigma0[2]   };; // ROTR(a,39)
 565 { .mib;         add     D=D,T1
 566                 mux2    H=X[15],0x44        }   // mov H=X[15] in sha512
 567 { .mib;         xor     r8=r8,r9                // Sigma0(a)
 568                 add     X[15]=T1,T2             // H=T1+Maj(a,b,c)
 569         br.ctop.sptk    .L_rest             };;
 570 .L_rest_end:
 571
 572 { .mmi; add     A=A,r8                  };;     // H+=Sigma0(a) from the past
 573 { .mmi; add     A_=A_,A
 574         add     B_=B_,B
 575         add     C_=C_,C                 }
 576 { .mmi; add     D_=D_,D
 577         add     E_=E_,E
 578         cmp.ltu p16,p0=1,num            };;
 579 { .mmi; add     F_=F_,F
 580         add     G_=G_,G
 581         add     H_=H_,H                 }
 582 { .mmb; add     Ktbl=-$SZ*$rounds,Ktbl
 583 (p16)   add     num=-1,num
 584 (p16)   br.dptk.many    .L_outer        };;
 585
 586 { .mib; add     r8=0*$SZ,ctx
 587         add     r9=1*$SZ,ctx            }
 588 { .mib; add     r10=2*$SZ,ctx
 589         add     r11=3*$SZ,ctx           };;
 590 { .mmi; $STW    [r8]=A_,4*$SZ
 591         $STW    [r9]=B_,4*$SZ
 592         mov     ar.lc=lcsave            }
 593 { .mmi; $STW    [r10]=C_,4*$SZ
 594         $STW    [r11]=D_,4*$SZ
 595         mov     pr=prsave,0x1ffff       };;
 596 { .mmb; $STW    [r8]=E_
 597         $STW    [r9]=F_                 }
 598 { .mmb; $STW    [r10]=G_
 599         $STW    [r11]=H_
 600         br.ret.sptk.many        b0      };;
 601 .endp   $func#
 602 ___
 603
 604 foreach(split($/,$code)) {
 605     s/\`([^\`]*)\`/eval $1/gem;
 606     s/_rotr(\s+)([^=]+)=([^,]+),([0-9]+)/shrp$1$2=$3,$3,$4/gm;
 607     if ($BITS==64) {
 608         s/mux2(\s+)([^=]+)=([^,]+),\S+/mov$1 $2=$3/gm;
 609         s/mux1(\s+)\S+/nop.i$1 0x0/gm   if ($big_endian);
 610         s/(shrp\s+X\[[^=]+)=([^,]+),([^,]+),([1-9]+)/$1=$3,$2,64-$4/gm
 611                                                 if (!$big_endian);
 612         s/ld1(\s+)X\[\S+/nop.m$1 0x0/gm;
 613     }
 614
 615     print $_,"\n";
 616 }
 617
 618 print<<___ if ($BITS==32);
 619 .align  64
 620 .type   K256#,\@object
 621 K256:   data4   0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
 622         data4   0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
 623         data4   0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
 624         data4   0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
 625         data4   0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
 626         data4   0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
 627         data4   0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
 628         data4   0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
 629         data4   0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
 630         data4   0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
 631         data4   0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
 632         data4   0xd192e819,0xd6990624,0xf40e3585,0x106aa070
 633         data4   0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
 634         data4   0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
 635         data4   0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
 636         data4   0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
 637 .size   K256#,$SZ*$rounds
 638 stringz "SHA256 block transform for IA64, CRYPTOGAMS by <appro\@openssl.org>"
 639 ___
 640 print<<___ if ($BITS==64);
 641 .align  64
 642 .type   K512#,\@object
 643 K512:   data8   0x428a2f98d728ae22,0x7137449123ef65cd
 644         data8   0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc
 645         data8   0x3956c25bf348b538,0x59f111f1b605d019
 646         data8   0x923f82a4af194f9b,0xab1c5ed5da6d8118
 647         data8   0xd807aa98a3030242,0x12835b0145706fbe
 648         data8   0x243185be4ee4b28c,0x550c7dc3d5ffb4e2
 649         data8   0x72be5d74f27b896f,0x80deb1fe3b1696b1
 650         data8   0x9bdc06a725c71235,0xc19bf174cf692694
 651         data8   0xe49b69c19ef14ad2,0xefbe4786384f25e3
 652         data8   0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65
 653         data8   0x2de92c6f592b0275,0x4a7484aa6ea6e483
 654         data8   0x5cb0a9dcbd41fbd4,0x76f988da831153b5
 655         data8   0x983e5152ee66dfab,0xa831c66d2db43210
 656         data8   0xb00327c898fb213f,0xbf597fc7beef0ee4
 657         data8   0xc6e00bf33da88fc2,0xd5a79147930aa725
 658         data8   0x06ca6351e003826f,0x142929670a0e6e70
 659         data8   0x27b70a8546d22ffc,0x2e1b21385c26c926
 660         data8   0x4d2c6dfc5ac42aed,0x53380d139d95b3df
 661         data8   0x650a73548baf63de,0x766a0abb3c77b2a8
 662         data8   0x81c2c92e47edaee6,0x92722c851482353b
 663         data8   0xa2bfe8a14cf10364,0xa81a664bbc423001
 664         data8   0xc24b8b70d0f89791,0xc76c51a30654be30
 665         data8   0xd192e819d6ef5218,0xd69906245565a910
 666         data8   0xf40e35855771202a,0x106aa07032bbd1b8
 667         data8   0x19a4c116b8d2d0c8,0x1e376c085141ab53
 668         data8   0x2748774cdf8eeb99,0x34b0bcb5e19b48a8
 669         data8   0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb
 670         data8   0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3
 671         data8   0x748f82ee5defb2fc,0x78a5636f43172f60
 672         data8   0x84c87814a1f0ab72,0x8cc702081a6439ec
 673         data8   0x90befffa23631e28,0xa4506cebde82bde9
 674         data8   0xbef9a3f7b2c67915,0xc67178f2e372532b
 675         data8   0xca273eceea26619c,0xd186b8c721c0c207
 676         data8   0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178
 677         data8   0x06f067aa72176fba,0x0a637dc5a2c898a6
 678         data8   0x113f9804bef90dae,0x1b710b35131c471b
 679         data8   0x28db77f523047d84,0x32caab7b40c72493
 680         data8   0x3c9ebe0a15c9bebc,0x431d67c49c100d4c
 681         data8   0x4cc5d4becb3e42b6,0x597f299cfc657e2a
 682         data8   0x5fcb6fab3ad6faec,0x6c44198c4a475817
 683 .size   K512#,$SZ*$rounds
 684 stringz "SHA512 block transform for IA64, CRYPTOGAMS by <appro\@openssl.org>"
 685 ___