Less vax.

ok deraadt@

4 files changed, 1 insertions, 617 deletions

diff --git a/src/lib/libcrypto/arch/vax/Makefile.inc b/src/lib/libcrypto/arch/vax/Makefile.inc
deleted file mode 100644
index f7764cf44a..0000000000
--- a/src/lib/libcrypto/arch/vax/Makefile.inc
+++ /dev/null
@@ -1,21 +0,0 @@
-# $OpenBSD: Makefile.inc,v 1.2 2014/11/17 20:31:22 miod Exp $
-
-# vax-specific libcrypto build rules
-
-# aes
-CFLAGS+=-DOPENSSL_NO_ASM
-SRCS+= aes_core.c aes_cbc.c 
-# bf
-SRCS+= bf_enc.c
-# bn
-SRCS+= bn_asm_vax.S
-# camellia
-SRCS+= camellia.c cmll_cbc.c cmll_misc.c
-# des
-SRCS+= des_enc.c fcrypt_b.c
-# rc4
-SRCS+= rc4_enc.c rc4_skey.c
-## rc5
-#SRCS+= rc5_enc.c 
-# whrlpool
-SRCS+= wp_block.c
diff --git a/src/lib/libcrypto/arch/vax/bn_asm_vax.S b/src/lib/libcrypto/arch/vax/bn_asm_vax.S
deleted file mode 100644
index 2969ae9dac..0000000000
--- a/src/lib/libcrypto/arch/vax/bn_asm_vax.S
+++ /dev/null
@@ -1,436 +0,0 @@
-#       $OpenBSD: bn_asm_vax.S,v 1.1 2014/04/11 22:51:53 miod Exp $
-#       $NetBSD: bn_asm_vax.S,v 1.1 2003/11/03 10:22:28 ragge Exp $
-
-#include <machine/asm.h>
-
-# w.j.m. 15-jan-1999
-#
-# it's magic ...
-#
-# ULONG bn_mul_add_words(ULONG r[],ULONG a[],int n,ULONG w) {
-#       ULONG c = 0;
-#       int i;
-#       for(i = 0; i < n; i++) <c,r[i]> := r[i] + c + a[i] * w ;
-#       return c;
-# }
-
-ENTRY(bn_mul_add_words,R6)
-        movl    4(%ap),%r2              # *r
-        movl    8(%ap),%r3              # *a
-        movl    12(%ap),%r4             # n
-        movl    16(%ap),%r5             # w
-        clrl    %r6                     # return value ("carry")
-
-0:      emul    %r5,(%r3),(%r2),%r0     # w * a[0] + r[0] -> r0
-
-        # fixup for "negative" r[]
-        tstl    (%r2)
-        bgeq    1f
-        incl    %r1                     # add 1 to highword
-
-1:      # add saved carry to result
-        addl2   %r6,%r0
-        adwc    $0,%r1
-
-        # combined fixup for "negative" w, a[]
-        tstl    %r5             # if w is negative...
-        bgeq    1f
-        addl2   (%r3),%r1       # ...add a[0] again to highword
-1:      tstl    (%r3)           # if a[0] is negative...
-        bgeq    1f
-        addl2   %r5,%r1         # ...add w again to highword
-1:
-        movl    %r0,(%r2)+      # save low word in dest & advance *r
-        addl2   $4,%r3          # advance *a
-        movl    %r1,%r6         # high word in r6 for return value
-
-        sobgtr  %r4,0b          # loop?
-
-        movl    %r6,%r0
-        ret
-
-#       .title  vax_bn_mul_words  unsigned multiply & add, 32*32+32=>64
-#;
-#; w.j.m. 15-jan-1999
-#;
-#; it's magic ...
-#;
-#; ULONG bn_mul_words(ULONG r[],ULONG a[],int n,ULONG w) {
-#;      ULONG c = 0;
-#;      int i;
-#;      for(i = 0; i < num; i++) <c,r[i]> := a[i] * w + c ;
-#;      return(c);
-#; }
-#
-
-ENTRY(bn_mul_words,R6)
-        movl    4(%ap),%r2              # *r
-        movl    8(%ap),%r3              # *a
-        movl    12(%ap),%r4             # n
-        movl    16(%ap),%r5             # w
-        clrl    %r6                     # carry
-
-0:      emul    %r5,(%r3),%r6,%r0       # w * a[0] + carry -> r0
-
-        # fixup for "negative" carry
-        tstl    %r6
-        bgeq    1f
-        incl    %r1
-
-1:      # combined fixup for "negative" w, a[]
-        tstl    %r5
-        bgeq    1f
-        addl2   (%r3),%r1
-1:      tstl    (%r3)
-        bgeq    1f
-        addl2   %r5,%r1
-
-1:      movl    %r0,(%r2)+
-        addl2   $4,%r3
-        movl    %r1,%r6
-
-        sobgtr  %r4,0b
-
-        movl    %r6,%r0
-        ret
-
-
-
-#       .title  vax_bn_sqr_words  unsigned square, 32*32=>64
-#;
-#; w.j.m. 15-jan-1999
-#;
-#; it's magic ...
-#;
-#; void bn_sqr_words(ULONG r[],ULONG a[],int n) {
-#;      int i;
-#;      for(i = 0; i < n; i++) <r[2*i+1],r[2*i]> := a[i] * a[i] ;
-#; }
-#
-
-ENTRY(bn_sqr_words,0)
-        movl    4(%ap),%r2              # r
-        movl    8(%ap),%r3              # a
-        movl    12(%ap),%r4             # n
-
-0:      movl    (%r3)+,%r5              # r5 = a[] & advance
-
-        emul    %r5,%r5,$0,%r0          # a[0] * a[0] + 0 -> r0
-
-        # fixup for "negative" a[]
-        tstl    %r5
-        bgeq    1f
-        addl2   %r5,%r1
-        addl2   %r5,%r1
-
-1:      movq    %r0,(%r2)+              # store 64-bit result
-
-        sobgtr  %r4,0b                  # loop
-
-        ret
-
-
-#       .title  vax_bn_div_words  unsigned divide
-#;
-#; Richard Levitte 20-Nov-2000
-#;
-#; ULONG bn_div_words(ULONG h, ULONG l, ULONG d)
-#; {
-#;      return ((ULONG)((((ULLONG)h)<<32)|l) / (ULLONG)d);
-#; }
-#;
-#; Using EDIV would be very easy, if it didn't do signed calculations.
-#; Any time any of the input numbers are signed, there are problems,
-#; usually with integer overflow, at which point it returns useless
-#; data (the quotient gets the value of l, and the remainder becomes 0).
-#;
-#; If it was just for the dividend, it would be very easy, just divide
-#; it by 2 (unsigned), do the division, multiply the resulting quotient
-#; and remainder by 2, add the bit that was dropped when dividing by 2
-#; to the remainder, and do some adjustment so the remainder doesn't
-#; end up larger than the divisor.  For some cases when the divisor is
-#; negative (from EDIV's point of view, i.e. when the highest bit is set),
-#; dividing the dividend by 2 isn't enough, and since some operations
-#; might generate integer overflows even when the dividend is divided by
-#; 4 (when the high part of the shifted down dividend ends up being exactly
-#; half of the divisor, the result is the quotient 0x80000000, which is
-#; negative...) it needs to be divided by 8.  Furthermore, the divisor needs
-#; to be divided by 2 (unsigned) as well, to avoid more problems with the sign.
-#; In this case, a little extra fiddling with the remainder is required.
-#;
-#; So, the simplest way to handle this is always to divide the dividend
-#; by 8, and to divide the divisor by 2 if it's highest bit is set.
-#; After EDIV has been used, the quotient gets multiplied by 8 if the
-#; original divisor was positive, otherwise 4.  The remainder, oddly
-#; enough, is *always* multiplied by 8.
-#; NOTE: in the case mentioned above, where the high part of the shifted
-#; down dividend ends up being exactly half the shifted down divisor, we
-#; end up with a 33 bit quotient.  That's no problem however, it usually
-#; means we have ended up with a too large remainder as well, and the
-#; problem is fixed by the last part of the algorithm (next paragraph).
-#;
-#; The routine ends with comparing the resulting remainder with the
-#; original divisor and if the remainder is larger, subtract the
-#; original divisor from it, and increase the quotient by 1.  This is
-#; done until the remainder is smaller than the divisor.
-#;
-#; The complete algorithm looks like this:
-#;
-#; d'    = d
-#; l'    = l & 7
-#; [h,l] = [h,l] >> 3
-#; [q,r] = floor([h,l] / d)     # This is the EDIV operation
-#; if (q < 0) q = -q            # I doubt this is necessary any more
-#;
-#; r'    = r >> 29
-#; if (d' >= 0)
-#;   q'  = q >> 29
-#;   q   = q << 3
-#; else
-#;   q'  = q >> 30
-#;   q   = q << 2
-#; r     = (r << 3) + l'
-#;
-#; if (d' < 0)
-#;   {
-#;     [r',r] = [r',r] - q
-#;     while ([r',r] < 0)
-#;       {
-#;         [r',r] = [r',r] + d
-#;         [q',q] = [q',q] - 1
-#;       }
-#;   }
-#;
-#; while ([r',r] >= d')
-#;   {
-#;     [r',r] = [r',r] - d'
-#;     [q',q] = [q',q] + 1
-#;   }
-#;
-#; return q
-#
-#;r2 = l, q
-#;r3 = h, r
-#;r4 = d
-#;r5 = l'
-#;r6 = r'
-#;r7 = d'
-#;r8 = q'
-#
-
-ENTRY(bn_div_words,R6|R7|R8)
-        movl    4(%ap),%r3              # h
-        movl    8(%ap),%r2              # l
-        movl    12(%ap),%r4             # d
-
-        bicl3   $-8,%r2,%r5             # l' = l & 7
-        bicl3   $7,%r2,%r2
-
-        bicl3   $-8,%r3,%r6
-        bicl3   $7,%r3,%r3
-
-        addl2   %r6,%r2
-
-        rotl    $-3,%r2,%r2             # l = l >> 3
-        rotl    $-3,%r3,%r3             # h = h >> 3
-
-        movl    %r4,%r7                 # d' = d
-
-        clrl    %r6                     # r' = 0
-        clrl    %r8                     # q' = 0
-
-        tstl    %r4
-        beql    0f                      # Uh-oh, the divisor is 0...
-        bgtr    1f
-        rotl    $-1,%r4,%r4     # If d is negative, shift it right.
-        bicl2   $0x80000000,%r4 # Since d is then a large number, the
-                                # lowest bit is insignificant
-                                # (contradict that, and I'll fix the problem!)
-1:
-        ediv    %r4,%r2,%r2,%r3         # Do the actual division
-
-        tstl    %r2
-        bgeq    1f
-        mnegl   %r2,%r2         # if q < 0, negate it
-1:
-        tstl    %r7
-        blss    1f
-        rotl    $3,%r2,%r2      #   q = q << 3
-        bicl3   $-8,%r2,%r8     #   q' gets the high bits from q
-        bicl3   $7,%r2,%r2
-        brb     2f
-
-1:                              # else
-        rotl    $2,%r2,%r2      #   q = q << 2
-        bicl3   $-4,%r2,%r8     #   q' gets the high bits from q
-        bicl3   $3,%r2,%r2
-2:
-        rotl    $3,%r3,%r3      # r = r << 3
-        bicl3   $-8,%r3,%r6     # r' gets the high bits from r
-        bicl3   $7,%r3,%r3
-        addl2   %r5,%r3         # r = r + l'
-
-        tstl    %r7
-        bgeq    5f
-        bitl    $1,%r7
-        beql    5f              # if d' < 0 && d' & 1
-        subl2   %r2,%r3         #   [r',r] = [r',r] - [q',q]
-        sbwc    %r8,%r6
-3:
-        bgeq    5f              #   while r < 0
-        decl    %r2             #     [q',q] = [q',q] - 1
-        sbwc    $0,%r8
-        addl2   %r7,%r3         #     [r',r] = [r',r] + d'
-        adwc    $0,%r6
-        brb     3b
-
-# The return points are placed in the middle to keep a short distance from
-# all the branch points
-1:
-#       movl    %r3,%r1
-        movl    %r2,%r0
-        ret
-0:
-        movl    $-1,%r0
-        ret
-5:
-        tstl    %r6
-        bneq    6f
-        cmpl    %r3,%r7
-        blssu   1b              # while [r',r] >= d'
-6:
-        subl2   %r7,%r3         #   [r',r] = [r',r] - d'
-        sbwc    $0,%r6
-        incl    %r2             #   [q',q] = [q',q] + 1
-        adwc    $0,%r8
-        brb     5b
-
-
-
-#       .title  vax_bn_add_words  unsigned add of two arrays
-#;
-#; Richard Levitte 20-Nov-2000
-#;
-#; ULONG bn_add_words(ULONG r[], ULONG a[], ULONG b[], int n) {
-#;      ULONG c = 0;
-#;      int i;
-#;      for (i = 0; i < n; i++) <c,r[i]> = a[i] + b[i] + c;
-#;      return(c);
-#; }
-#
-
-ENTRY(bn_add_words,0)
-        movl    4(%ap),%r2      # r
-        movl    8(%ap),%r3      # a
-        movl    12(%ap),%r4     # b
-        movl    16(%ap),%r5     # n
-        clrl    %r0
-
-        tstl    %r5
-        bleq    1f
-
-0:      movl    (%r3)+,%r1      # carry untouched
-        adwc    (%r4)+,%r1      # carry used and touched
-        movl    %r1,(%r2)+      # carry untouched
-        sobgtr  %r5,0b          # carry untouched
-
-        adwc    $0,%r0
-1:      ret
-
-#;
-#; Richard Levitte 20-Nov-2000
-#;
-#; ULONG bn_sub_words(ULONG r[], ULONG a[], ULONG b[], int n) {
-#;      ULONG c = 0;
-#;      int i;
-#;      for (i = 0; i < n; i++) <c,r[i]> = a[i] - b[i] - c;
-#;      return(c);
-#; }
-#
-
-ENTRY(bn_sub_words,R6)
-        movl    4(%ap),%r2      # r
-        movl    8(%ap),%r3      # a
-        movl    12(%ap),%r4     # b
-        movl    16(%ap),%r5     # n
-        clrl    %r0
-
-        tstl    %r5
-        bleq    1f
-
-0:      movl    (%r3)+,%r6      # carry untouched
-        sbwc    (%r4)+,%r6      # carry used and touched
-        movl    %r6,(%r2)+      # carry untouched
-        sobgtr  %r5,0b          # carry untouched
-
-1:      adwc    $0,%r0
-        ret
-
-#
-#       Ragge 20-Sep-2003
-#
-#       Multiply a vector of 4/8 longword by another.
-#       Uses two loops and 16/64 emuls.
-#
-
-ENTRY(bn_mul_comba4,R6|R7|R8|R9)
-        movl    $4,%r9          # 4*4
-        brb     6f
-
-ENTRY(bn_mul_comba8,R6|R7|R8|R9)
-        movl    $8,%r9          # 8*8
-
-6:      movl    8(%ap),%r3      # a[]
-        movl    12(%ap),%r7     # b[]
-        brb     5f
-
-ENTRY(bn_sqr_comba4,R6|R7|R8|R9)
-        movl    $4,%r9          # 4*4
-        brb 0f
-
-ENTRY(bn_sqr_comba8,R6|R7|R8|R9)
-        movl    $8,%r9          # 8*8
-
-0:
-        movl    8(%ap),%r3      # a[]
-        movl    %r3,%r7         # a[]
-
-5:      movl    4(%ap),%r5      # r[]
-        movl    %r9,%r8
-
-        clrq    (%r5)           # clear destinatino, for add.
-        clrq    8(%r5)
-        clrq    16(%r5)         # these only needed for comba8
-        clrq    24(%r5)
-
-2:      clrl    %r4             # carry
-        movl    %r9,%r6         # inner loop count
-        movl    (%r7)+,%r2      # value to multiply with
-
-1:      emul    %r2,(%r3),%r4,%r0
-        tstl    %r4
-        bgeq    3f
-        incl    %r1
-3:      tstl    %r2
-        bgeq    3f
-        addl2   (%r3),%r1
-3:      tstl    (%r3)
-        bgeq    3f
-        addl2   %r2,%r1
-
-3:      addl2   %r0,(%r5)+      # add to destination
-        adwc    $0,%r1          # remember carry
-        movl    %r1,%r4         # add carry in next emul
-        addl2   $4,%r3
-        sobgtr  %r6,1b
-
-        movl    %r4,(%r5)       # save highest add result
-
-        ashl    $2,%r9,%r4
-        subl2   %r4,%r3
-        subl2   $4,%r4
-        subl2   %r4,%r5
-
-        sobgtr  %r8,2b
-
-        ret
diff --git a/src/lib/libcrypto/arch/vax/opensslconf.h b/src/lib/libcrypto/arch/vax/opensslconf.h
deleted file mode 100644
index e3795ce73a..0000000000
--- a/src/lib/libcrypto/arch/vax/opensslconf.h
+++ /dev/null
@@ -1,157 +0,0 @@
-#include <openssl/opensslfeatures.h>
-/* crypto/opensslconf.h.in */
-
-/* Generate 80386 code? */
-#undef I386_ONLY
-
-#if defined(HEADER_CRYPTLIB_H) && !defined(OPENSSLDIR)
-#define OPENSSLDIR "/etc/ssl"
-#endif
-
-#undef OPENSSL_UNISTD
-#define OPENSSL_UNISTD <unistd.h>
-
-#undef OPENSSL_EXPORT_VAR_AS_FUNCTION
-
-#if defined(HEADER_IDEA_H) && !defined(IDEA_INT)
-#define IDEA_INT unsigned int
-#endif
-
-#if defined(HEADER_MD2_H) && !defined(MD2_INT)
-#define MD2_INT unsigned int
-#endif
-
-#if defined(HEADER_RC2_H) && !defined(RC2_INT)
-/* I need to put in a mod for the alpha - eay */
-#define RC2_INT unsigned int
-#endif
-
-#if defined(HEADER_RC4_H)
-#if !defined(RC4_INT)
-/* using int types make the structure larger but make the code faster
- * on most boxes I have tested - up to %20 faster. */
-/*
- * I don't know what does "most" mean, but declaring "int" is a must on:
- * - Intel P6 because partial register stalls are very expensive;
- * - elder Alpha because it lacks byte load/store instructions;
- */
-#define RC4_INT unsigned int
-#endif
-#if !defined(RC4_CHUNK)
-/*
- * This enables code handling data aligned at natural CPU word
- * boundary. See crypto/rc4/rc4_enc.c for further details.
- */
-#undef RC4_CHUNK
-#endif
-#endif
-
-#if (defined(HEADER_NEW_DES_H) || defined(HEADER_DES_H)) && !defined(DES_LONG)
-/* If this is set to 'unsigned int' on a DEC Alpha, this gives about a
- * %20 speed up (longs are 8 bytes, int's are 4). */
-#ifndef DES_LONG
-#define DES_LONG unsigned int
-#endif
-#endif
-
-#if defined(HEADER_BN_H) && !defined(CONFIG_HEADER_BN_H)
-#define CONFIG_HEADER_BN_H
-#define BN_LLONG
-
-/* Should we define BN_DIV2W here? */
-
-/* Only one for the following should be defined */
-/* The prime number generation stuff may not work when
- * EIGHT_BIT but I don't care since I've only used this mode
- * for debuging the bignum libraries */
-#undef SIXTY_FOUR_BIT_LONG
-#undef SIXTY_FOUR_BIT
-#define THIRTY_TWO_BIT
-#undef SIXTEEN_BIT
-#undef EIGHT_BIT
-#endif
-
-#if defined(HEADER_RC4_LOCL_H) && !defined(CONFIG_HEADER_RC4_LOCL_H)
-#define CONFIG_HEADER_RC4_LOCL_H
-/* if this is defined data[i] is used instead of *data, this is a %20
- * speedup on x86 */
-#define RC4_INDEX
-#endif
-
-#if defined(HEADER_BF_LOCL_H) && !defined(CONFIG_HEADER_BF_LOCL_H)
-#define CONFIG_HEADER_BF_LOCL_H
-#undef BF_PTR
-#endif /* HEADER_BF_LOCL_H */
-
-#if defined(HEADER_DES_LOCL_H) && !defined(CONFIG_HEADER_DES_LOCL_H)
-#define CONFIG_HEADER_DES_LOCL_H
-#ifndef DES_DEFAULT_OPTIONS
-/* the following is tweaked from a config script, that is why it is a
- * protected undef/define */
-#ifndef DES_PTR
-#undef DES_PTR
-#endif
-
-/* This helps C compiler generate the correct code for multiple functional
- * units.  It reduces register dependancies at the expense of 2 more
- * registers */
-#ifndef DES_RISC1
-#undef DES_RISC1
-#endif
-
-#ifndef DES_RISC2
-#undef DES_RISC2
-#endif
-
-#if defined(DES_RISC1) && defined(DES_RISC2)
-YOU SHOULD NOT HAVE BOTH DES_RISC1 AND DES_RISC2 DEFINED!!!!!
-#endif
-
-/* Unroll the inner loop, this sometimes helps, sometimes hinders.
- * Very mucy CPU dependant */
-#ifndef DES_UNROLL
-#define DES_UNROLL
-#endif
-
-/* These default values were supplied by
- * Peter Gutman <pgut001@cs.auckland.ac.nz>
- * They are only used if nothing else has been defined */
-#if !defined(DES_PTR) && !defined(DES_RISC1) && !defined(DES_RISC2) && !defined(DES_UNROLL)
-/* Special defines which change the way the code is built depending on the
-   CPU and OS.  For SGI machines you can use _MIPS_SZLONG (32 or 64) to find
-   even newer MIPS CPU's, but at the moment one size fits all for
-   optimization options.  Older Sparc's work better with only UNROLL, but
-   there's no way to tell at compile time what it is you're running on */
- 
-#if defined( sun )              /* Newer Sparc's */
-#  define DES_PTR
-#  define DES_RISC1
-#  define DES_UNROLL
-#elif defined( __ultrix )       /* Older MIPS */
-#  define DES_PTR
-#  define DES_RISC2
-#  define DES_UNROLL
-#elif defined( __osf1__ )       /* Alpha */
-#  define DES_PTR
-#  define DES_RISC2
-#elif defined ( _AIX )          /* RS6000 */
-  /* Unknown */
-#elif defined( __hpux )         /* HP-PA */
-  /* Unknown */
-#elif defined( __aux )          /* 68K */
-  /* Unknown */
-#elif defined( __dgux )         /* 88K (but P6 in latest boxes) */
-#  define DES_UNROLL
-#elif defined( __sgi )          /* Newer MIPS */
-#  define DES_PTR
-#  define DES_RISC2
-#  define DES_UNROLL
-#elif defined(i386) || defined(__i386__)        /* x86 boxes, should be gcc */
-#  define DES_PTR
-#  define DES_RISC1
-#  define DES_UNROLL
-#endif /* Systems-specific speed defines */
-#endif
-
-#endif /* DES_DEFAULT_OPTIONS */
-#endif /* HEADER_DES_LOCL_H */
diff --git a/src/lib/libcrypto/whrlpool/wp_block.c b/src/lib/libcrypto/whrlpool/wp_block.c
index 9a681c2888..57f5b5df7a 100644
--- a/src/lib/libcrypto/whrlpool/wp_block.c
+++ b/src/lib/libcrypto/whrlpool/wp_block.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: wp_block.c,v 1.10 2016/03/15 20:50:22 krw Exp $ */
+/* $OpenBSD: wp_block.c,v 1.11 2016/09/04 13:39:48 jsing Exp $ */
 /**
  * The Whirlpool hashing function.
  *
@@ -66,8 +66,6 @@ typedef unsigned long long	u64;
 #  endif
 #elif defined(__arm__)
 #  define SMALL_REGISTER_BANK
-#elif defined(__vax__)
-#  define SMALL_REGISTER_BANK
 #endif
 
 #undef ROTATE