Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5c380d62 authored by Leonidas S. Barbosa's avatar Leonidas S. Barbosa Committed by Herbert Xu
Browse files

crypto: vmx - Add support for VMS instructions by ASM 



OpenSSL implements optimized ASM algorithms which support
VMX instructions on Power 8 CPU.

These scripts generate an endian-agnostic ASM implementation
in order to support both big and little-endian.
	- aesp8-ppc.pl: implements suport for AES instructions
	implemented by POWER8 processor.
	- ghashp8-ppc.pl: implements support for  GHASH for Power8.
	- ppc-xlate.pl:  ppc assembler distiller.

These code has been adopted from OpenSSL project in collaboration
with the original author (Andy Polyakov <appro@openssl.org>).

Signed-off-by: default avatarLeonidas S. Barbosa <leosilva@linux.vnet.ibm.com>
Signed-off-by: default avatarHerbert Xu <herbert@gondor.apana.org.au>
parent cc333cd6

drivers/crypto/vmx/aesp8-ppc.pl

0 → 100755
+1940 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/crypto/vmx/ghashp8-ppc.pl

0 → 100755
+234 −0
Original line number Diff line number Diff line 
#!/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/.

# ====================================================================

#

# GHASH for for PowerISA v2.07.

#

# July 2014

#

# Accurate performance measurements are problematic, because it's

# always virtualized setup with possibly throttled processor.

# Relative comparison is therefore more informative. This initial

# version is ~2.1x slower than hardware-assisted AES-128-CTR, ~12x

# faster than "4-bit" integer-only compiler-generated 64-bit code.

# "Initial version" means that there is room for futher improvement.



$flavour=shift;

$output =shift;



if ($flavour =~ /64/) {

	$SIZE_T=8;

	$LRSAVE=2*$SIZE_T;

	$STU="stdu";

	$POP="ld";

	$PUSH="std";

} elsif ($flavour =~ /32/) {

	$SIZE_T=4;

	$LRSAVE=$SIZE_T;

	$STU="stwu";

	$POP="lwz";

	$PUSH="stw";

} else { die "nonsense $flavour"; }



$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;

( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or

( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or

die "can't locate ppc-xlate.pl";



open STDOUT,"| $^X $xlate $flavour $output" || die "can't call $xlate: $!";



my ($Xip,$Htbl,$inp,$len)=map("r$_",(3..6));	# argument block



my ($Xl,$Xm,$Xh,$IN)=map("v$_",(0..3));

my ($zero,$t0,$t1,$t2,$xC2,$H,$Hh,$Hl,$lemask)=map("v$_",(4..12));

my $vrsave="r12";



$code=<<___;

.machine	"any"



.text



.globl	.gcm_init_p8

.align	5

.gcm_init_p8:

	lis		r0,0xfff0

	li		r8,0x10

	mfspr		$vrsave,256

	li		r9,0x20

	mtspr		256,r0

	li		r10,0x30

	lvx_u		$H,0,r4			# load H



	vspltisb	$xC2,-16		# 0xf0

	vspltisb	$t0,1			# one

	vaddubm		$xC2,$xC2,$xC2		# 0xe0

	vxor		$zero,$zero,$zero

	vor		$xC2,$xC2,$t0		# 0xe1

	vsldoi		$xC2,$xC2,$zero,15	# 0xe1...

	vsldoi		$t1,$zero,$t0,1		# ...1

	vaddubm		$xC2,$xC2,$xC2		# 0xc2...

	vspltisb	$t2,7

	vor		$xC2,$xC2,$t1		# 0xc2....01

	vspltb		$t1,$H,0		# most significant byte

	vsl		$H,$H,$t0		# H<<=1

	vsrab		$t1,$t1,$t2		# broadcast carry bit

	vand		$t1,$t1,$xC2

	vxor		$H,$H,$t1		# twisted H



	vsldoi		$H,$H,$H,8		# twist even more ...

	vsldoi		$xC2,$zero,$xC2,8	# 0xc2.0

	vsldoi		$Hl,$zero,$H,8		# ... and split

	vsldoi		$Hh,$H,$zero,8



	stvx_u		$xC2,0,r3		# save pre-computed table

	stvx_u		$Hl,r8,r3

	stvx_u		$H, r9,r3

	stvx_u		$Hh,r10,r3



	mtspr		256,$vrsave

	blr

	.long		0

	.byte		0,12,0x14,0,0,0,2,0

	.long		0

.size	.gcm_init_p8,.-.gcm_init_p8



.globl	.gcm_gmult_p8

.align	5

.gcm_gmult_p8:

	lis		r0,0xfff8

	li		r8,0x10

	mfspr		$vrsave,256

	li		r9,0x20

	mtspr		256,r0

	li		r10,0x30

	lvx_u		$IN,0,$Xip		# load Xi



	lvx_u		$Hl,r8,$Htbl		# load pre-computed table

	 le?lvsl	$lemask,r0,r0

	lvx_u		$H, r9,$Htbl

	 le?vspltisb	$t0,0x07

	lvx_u		$Hh,r10,$Htbl

	 le?vxor	$lemask,$lemask,$t0

	lvx_u		$xC2,0,$Htbl

	 le?vperm	$IN,$IN,$IN,$lemask

	vxor		$zero,$zero,$zero



	vpmsumd		$Xl,$IN,$Hl		# H.loXi.lo

	vpmsumd		$Xm,$IN,$H		# H.hiXi.lo+H.loXi.hi

	vpmsumd		$Xh,$IN,$Hh		# H.hiXi.hi



	vpmsumd		$t2,$Xl,$xC2		# 1st phase



	vsldoi		$t0,$Xm,$zero,8

	vsldoi		$t1,$zero,$Xm,8

	vxor		$Xl,$Xl,$t0

	vxor		$Xh,$Xh,$t1



	vsldoi		$Xl,$Xl,$Xl,8

	vxor		$Xl,$Xl,$t2



	vsldoi		$t1,$Xl,$Xl,8		# 2nd phase

	vpmsumd		$Xl,$Xl,$xC2

	vxor		$t1,$t1,$Xh

	vxor		$Xl,$Xl,$t1



	le?vperm	$Xl,$Xl,$Xl,$lemask

	stvx_u		$Xl,0,$Xip		# write out Xi



	mtspr		256,$vrsave

	blr

	.long		0

	.byte		0,12,0x14,0,0,0,2,0

	.long		0

.size	.gcm_gmult_p8,.-.gcm_gmult_p8



.globl	.gcm_ghash_p8

.align	5

.gcm_ghash_p8:

	lis		r0,0xfff8

	li		r8,0x10

	mfspr		$vrsave,256

	li		r9,0x20

	mtspr		256,r0

	li		r10,0x30

	lvx_u		$Xl,0,$Xip		# load Xi



	lvx_u		$Hl,r8,$Htbl		# load pre-computed table

	 le?lvsl	$lemask,r0,r0

	lvx_u		$H, r9,$Htbl

	 le?vspltisb	$t0,0x07

	lvx_u		$Hh,r10,$Htbl

	 le?vxor	$lemask,$lemask,$t0

	lvx_u		$xC2,0,$Htbl

	 le?vperm	$Xl,$Xl,$Xl,$lemask

	vxor		$zero,$zero,$zero



	lvx_u		$IN,0,$inp

	addi		$inp,$inp,16

	subi		$len,$len,16

	 le?vperm	$IN,$IN,$IN,$lemask

	vxor		$IN,$IN,$Xl

	b		Loop



.align	5

Loop:

	 subic		$len,$len,16

	vpmsumd		$Xl,$IN,$Hl		# H.loXi.lo

	 subfe.		r0,r0,r0		# borrow?-1:0

	vpmsumd		$Xm,$IN,$H		# H.hiXi.lo+H.loXi.hi

	 and		r0,r0,$len

	vpmsumd		$Xh,$IN,$Hh		# H.hiXi.hi

	 add		$inp,$inp,r0



	vpmsumd		$t2,$Xl,$xC2		# 1st phase



	vsldoi		$t0,$Xm,$zero,8

	vsldoi		$t1,$zero,$Xm,8

	vxor		$Xl,$Xl,$t0

	vxor		$Xh,$Xh,$t1



	vsldoi		$Xl,$Xl,$Xl,8

	vxor		$Xl,$Xl,$t2

	 lvx_u		$IN,0,$inp

	 addi		$inp,$inp,16



	vsldoi		$t1,$Xl,$Xl,8		# 2nd phase

	vpmsumd		$Xl,$Xl,$xC2

	 le?vperm	$IN,$IN,$IN,$lemask

	vxor		$t1,$t1,$Xh

	vxor		$IN,$IN,$t1

	vxor		$IN,$IN,$Xl

	beq		Loop			# did $len-=16 borrow?



	vxor		$Xl,$Xl,$t1

	le?vperm	$Xl,$Xl,$Xl,$lemask

	stvx_u		$Xl,0,$Xip		# write out Xi



	mtspr		256,$vrsave

	blr

	.long		0

	.byte		0,12,0x14,0,0,0,4,0

	.long		0

.size	.gcm_ghash_p8,.-.gcm_ghash_p8



.asciz  "GHASH for PowerISA 2.07, CRYPTOGAMS by <appro\@openssl.org>"

.align  2

___



foreach (split("\n",$code)) {

	if ($flavour =~ /le$/o) {	# little-endian

	    s/le\?//o		or

	    s/be\?/#be#/o;

	} else {

	    s/le\?/#le#/o	or

	    s/be\?//o;

	}

	print $_,"\n";

}



close STDOUT; # enforce flush

drivers/crypto/vmx/ppc-xlate.pl

0 → 100755
+226 −0
Original line number Diff line number Diff line 
#!/usr/bin/env perl



# PowerPC assembler distiller by <appro>.



my $flavour = shift;

my $output = shift;

open STDOUT,">$output" || die "can't open $output: $!";



my %GLOBALS;

my $dotinlocallabels=($flavour=~/linux/)?1:0;



################################################################

# directives which need special treatment on different platforms

################################################################

my $globl = sub {

    my $junk = shift;

    my $name = shift;

    my $global = \$GLOBALS{$name};

    my $ret;



    $name =~ s|^[\.\_]||;

 

    SWITCH: for ($flavour) {

	/aix/		&& do { $name = ".$name";

				last;

			      };

	/osx/		&& do { $name = "_$name";

				last;

			      };

	/linux.*(32|64le)/

			&& do {	$ret .= ".globl	$name\n";

				$ret .= ".type	$name,\@function";

				last;

			      };

	/linux.*64/	&& do {	$ret .= ".globl	$name\n";

				$ret .= ".type	$name,\@function\n";

				$ret .= ".section	\".opd\",\"aw\"\n";

				$ret .= ".align	3\n";

				$ret .= "$name:\n";

				$ret .= ".quad	.$name,.TOC.\@tocbase,0\n";

				$ret .= ".previous\n";



				$name = ".$name";

				last;

			      };

    }



    $ret = ".globl	$name" if (!$ret);

    $$global = $name;

    $ret;

};

my $text = sub {

    my $ret = ($flavour =~ /aix/) ? ".csect\t.text[PR],7" : ".text";

    $ret = ".abiversion	2\n".$ret	if ($flavour =~ /linux.*64le/);

    $ret;

};

my $machine = sub {

    my $junk = shift;

    my $arch = shift;

    if ($flavour =~ /osx/)

    {	$arch =~ s/\"//g;

	$arch = ($flavour=~/64/) ? "ppc970-64" : "ppc970" if ($arch eq "any");

    }

    ".machine	$arch";

};

my $size = sub {

    if ($flavour =~ /linux/)

    {	shift;

	my $name = shift; $name =~ s|^[\.\_]||;

	my $ret  = ".size	$name,.-".($flavour=~/64$/?".":"").$name;

	$ret .= "\n.size	.$name,.-.$name" if ($flavour=~/64$/);

	$ret;

    }

    else

    {	"";	}

};

my $asciz = sub {

    shift;

    my $line = join(",",@_);

    if ($line =~ /^"(.*)"$/)

    {	".byte	" . join(",",unpack("C*",$1),0) . "\n.align	2";	}

    else

    {	"";	}

};

my $quad = sub {

    shift;

    my @ret;

    my ($hi,$lo);

    for (@_) {

	if (/^0x([0-9a-f]*?)([0-9a-f]{1,8})$/io)

	{  $hi=$1?"0x$1":"0"; $lo="0x$2";  }

	elsif (/^([0-9]+)$/o)

	{  $hi=$1>>32; $lo=$1&0xffffffff;  } # error-prone with 32-bit perl

	else

	{  $hi=undef; $lo=$_; }



	if (defined($hi))

	{  push(@ret,$flavour=~/le$/o?".long\t$lo,$hi":".long\t$hi,$lo");  }

	else

	{  push(@ret,".quad	$lo");  }

    }

    join("\n",@ret);

};



################################################################

# simplified mnemonics not handled by at least one assembler

################################################################

my $cmplw = sub {

    my $f = shift;

    my $cr = 0; $cr = shift if ($#_>1);

    # Some out-of-date 32-bit GNU assembler just can't handle cmplw...

    ($flavour =~ /linux.*32/) ?

	"	.long	".sprintf "0x%x",31<<26|$cr<<23|$_[0]<<16|$_[1]<<11|64 :

	"	cmplw	".join(',',$cr,@_);

};

my $bdnz = sub {

    my $f = shift;

    my $bo = $f=~/[\+\-]/ ? 16+9 : 16;	# optional "to be taken" hint

    "	bc	$bo,0,".shift;

} if ($flavour!~/linux/);

my $bltlr = sub {

    my $f = shift;

    my $bo = $f=~/\-/ ? 12+2 : 12;	# optional "not to be taken" hint

    ($flavour =~ /linux/) ?		# GNU as doesn't allow most recent hints

	"	.long	".sprintf "0x%x",19<<26|$bo<<21|16<<1 :

	"	bclr	$bo,0";

};

my $bnelr = sub {

    my $f = shift;

    my $bo = $f=~/\-/ ? 4+2 : 4;	# optional "not to be taken" hint

    ($flavour =~ /linux/) ?		# GNU as doesn't allow most recent hints

	"	.long	".sprintf "0x%x",19<<26|$bo<<21|2<<16|16<<1 :

	"	bclr	$bo,2";

};

my $beqlr = sub {

    my $f = shift;

    my $bo = $f=~/-/ ? 12+2 : 12;	# optional "not to be taken" hint

    ($flavour =~ /linux/) ?		# GNU as doesn't allow most recent hints

	"	.long	".sprintf "0x%X",19<<26|$bo<<21|2<<16|16<<1 :

	"	bclr	$bo,2";

};

# GNU assembler can't handle extrdi rA,rS,16,48, or when sum of last two

# arguments is 64, with "operand out of range" error.

my $extrdi = sub {

    my ($f,$ra,$rs,$n,$b) = @_;

    $b = ($b+$n)&63; $n = 64-$n;

    "	rldicl	$ra,$rs,$b,$n";

};

my $vmr = sub {

    my ($f,$vx,$vy) = @_;

    "	vor	$vx,$vy,$vy";

};



# PowerISA 2.06 stuff

sub vsxmem_op {

    my ($f, $vrt, $ra, $rb, $op) = @_;

    "	.long	".sprintf "0x%X",(31<<26)|($vrt<<21)|($ra<<16)|($rb<<11)|($op*2+1);

}

# made-up unaligned memory reference AltiVec/VMX instructions

my $lvx_u	= sub {	vsxmem_op(@_, 844); };	# lxvd2x

my $stvx_u	= sub {	vsxmem_op(@_, 972); };	# stxvd2x

my $lvdx_u	= sub {	vsxmem_op(@_, 588); };	# lxsdx

my $stvdx_u	= sub {	vsxmem_op(@_, 716); };	# stxsdx

my $lvx_4w	= sub { vsxmem_op(@_, 780); };	# lxvw4x

my $stvx_4w	= sub { vsxmem_op(@_, 908); };	# stxvw4x



# PowerISA 2.07 stuff

sub vcrypto_op {

    my ($f, $vrt, $vra, $vrb, $op) = @_;

    "	.long	".sprintf "0x%X",(4<<26)|($vrt<<21)|($vra<<16)|($vrb<<11)|$op;

}

my $vcipher	= sub { vcrypto_op(@_, 1288); };

my $vcipherlast	= sub { vcrypto_op(@_, 1289); };

my $vncipher	= sub { vcrypto_op(@_, 1352); };

my $vncipherlast= sub { vcrypto_op(@_, 1353); };

my $vsbox	= sub { vcrypto_op(@_, 0, 1480); };

my $vshasigmad	= sub { my ($st,$six)=splice(@_,-2); vcrypto_op(@_, $st<<4|$six, 1730); };

my $vshasigmaw	= sub { my ($st,$six)=splice(@_,-2); vcrypto_op(@_, $st<<4|$six, 1666); };

my $vpmsumb	= sub { vcrypto_op(@_, 1032); };

my $vpmsumd	= sub { vcrypto_op(@_, 1224); };

my $vpmsubh	= sub { vcrypto_op(@_, 1096); };

my $vpmsumw	= sub { vcrypto_op(@_, 1160); };

my $vaddudm	= sub { vcrypto_op(@_, 192);  };



my $mtsle	= sub {

    my ($f, $arg) = @_;

    "	.long	".sprintf "0x%X",(31<<26)|($arg<<21)|(147*2);

};



while($line=<>) {



    $line =~ s|[#!;].*$||;	# get rid of asm-style comments...

    $line =~ s|/\*.*\*/||;	# ... and C-style comments...

    $line =~ s|^\s+||;		# ... and skip white spaces in beginning...

    $line =~ s|\s+$||;		# ... and at the end



    {

	$line =~ s|\b\.L(\w+)|L$1|g;	# common denominator for Locallabel

	$line =~ s|\bL(\w+)|\.L$1|g	if ($dotinlocallabels);

    }



    {

	$line =~ s|(^[\.\w]+)\:\s*||;

	my $label = $1;

	if ($label) {

	    printf "%s:",($GLOBALS{$label} or $label);

	    printf "\n.localentry\t$GLOBALS{$label},0"	if ($GLOBALS{$label} && $flavour =~ /linux.*64le/);

	}

    }



    {

	$line =~ s|^\s*(\.?)(\w+)([\.\+\-]?)\s*||;

	my $c = $1; $c = "\t" if ($c eq "");

	my $mnemonic = $2;

	my $f = $3;

	my $opcode = eval("\$$mnemonic");

	$line =~ s/\b(c?[rf]|v|vs)([0-9]+)\b/$2/g if ($c ne "." and $flavour !~ /osx/);

	if (ref($opcode) eq 'CODE') { $line = &$opcode($f,split(',',$line)); }

	elsif ($mnemonic)           { $line = $c.$mnemonic.$f."\t".$line; }

    }



    print $line if ($line);

    print "\n";

}



close STDOUT;