1 files changed, 241 insertions, 313 deletions

diff --git a/src/usr.bin/openssl/speed.c b/src/usr.bin/openssl/speed.c
index 9d03c6516e..1ece133f2e 100644
--- a/src/usr.bin/openssl/speed.c
+++ b/src/usr.bin/openssl/speed.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: speed.c,v 1.41 2025/01/02 13:37:43 tb Exp $ */
+/* $OpenBSD: speed.c,v 1.50 2025/12/13 01:58:53 kenjiro Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -142,9 +142,6 @@
 #ifndef OPENSSL_NO_SHA
 #include <openssl/sha.h>
 #endif
-#ifndef OPENSSL_NO_WHIRLPOOL
-#include <openssl/whrlpool.h>
-#endif
 
 #define BUFSIZE (1024*8+64)
 volatile sig_atomic_t run;
@@ -152,29 +149,78 @@ volatile sig_atomic_t run;
 static int mr = 0;
 static int usertime = 1;
 
-static double Time_F(int s);
-static void print_message(const char *s, long num, int length);
+static void print_message(const char *s, int length);
 static void
 pkey_print_message(const char *str, const char *str2,
-    long num, int bits, int sec);
+    int bits, int sec);
 static void print_result(int alg, int run_no, int count, double time_used);
 static int do_multi(int multi);
 
-#define ALGOR_NUM       32
 #define SIZE_NUM        5
-#define RSA_NUM         4
-#define DSA_NUM         3
+#define MAX_ECDH_SIZE   256
+
+enum {
+        D_MD4,
+        D_MD5,
+        D_HMAC,
+        D_SHA1,
+        D_RMD160,
+        D_RC4,
+        D_CBC_DES,
+        D_EDE3_DES,
+        D_CBC_IDEA,
+        D_CBC_RC2,
+        D_CBC_BF,
+        D_CBC_CAST,
+        D_CBC_128_AES,
+        D_CBC_192_AES,
+        D_CBC_256_AES,
+        D_CBC_128_CML,
+        D_CBC_192_CML,
+        D_CBC_256_CML,
+        D_EVP,
+        D_SHA256,
+        D_SHA512,
+        D_IGE_128_AES,
+        D_IGE_192_AES,
+        D_IGE_256_AES,
+        D_GHASH,
+        D_AES_128_GCM,
+        D_AES_256_GCM,
+        D_CHACHA20_POLY1305,
+        ALGOR_NUM,
+};
+
+enum {
+        R_DSA_512,
+        R_DSA_1024,
+        R_DSA_2048,
+        DSA_NUM,
+};
+
+enum {
+        R_RSA_512,
+        R_RSA_1024,
+        R_RSA_2048,
+        R_RSA_4096,
+        RSA_NUM,
+};
 
-#define EC_NUM          4
-#define MAX_ECDH_SIZE 256
+enum {
+        R_EC_P224,
+        R_EC_P256,
+        R_EC_P384,
+        R_EC_P521,
+        EC_NUM,
+};
 
 static const char *names[ALGOR_NUM] = {
-        "md2", "md4", "md5", "hmac(md5)", "sha1", "rmd160",
-        "rc4", "des cbc", "des ede3", "idea cbc", "seed cbc",
-        "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
+        "md4", "md5", "hmac(sha256)", "sha1", "rmd160",
+        "rc4", "des cbc", "des ede3", "idea cbc",
+        "rc2 cbc", "blowfish cbc", "cast cbc",
         "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
         "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
-        "evp", "sha256", "sha512", "whirlpool",
+        "evp", "sha256", "sha512",
         "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",
         "aes-128 gcm", "aes-256 gcm", "chacha20 poly1305",
 };
@@ -895,6 +941,22 @@ static const unsigned char test4096[] = {
         0xaf, 0xf8, 0x2a, 0x91, 0x9d, 0x50, 0x44, 0x21, 0x17,
 };
 
+static const unsigned char key16[] = {
+        0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
+        0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
+};
+static const unsigned char key24[] = {
+        0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
+        0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
+        0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
+};
+static const unsigned char key32[] = {
+        0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
+        0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
+        0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
+        0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56,
+};
+
 static void
 sig_done(int sig)
 {
@@ -904,16 +966,14 @@ sig_done(int sig)
 #define START   TM_RESET
 #define STOP    TM_GET
 
-
 static double
-Time_F(int s)
+time_f(int s)
 {
         if (usertime)
                 return app_timer_user(s);
-        else
-                return app_timer_real(s);
-}
 
+        return app_timer_real(s);
+}
 
 static const int KDF1_SHA1_len = 20;
 static void *
@@ -937,33 +997,12 @@ speed_main(int argc, char **argv)
         unsigned char *buf = NULL, *buf2 = NULL;
         size_t unaligned = 0;
         int mret = 1;
-        long count = 0, save_count = 0;
+        long count = 0;
         int i, j, k;
         long rsa_count;
         unsigned rsa_num;
         unsigned char md[EVP_MAX_MD_SIZE];
-#ifndef OPENSSL_NO_MD4
-        unsigned char md4[MD4_DIGEST_LENGTH];
-#endif
-#ifndef OPENSSL_NO_MD5
-        unsigned char md5[MD5_DIGEST_LENGTH];
-        unsigned char hmac[MD5_DIGEST_LENGTH];
-#endif
-#ifndef OPENSSL_NO_SHA
-        unsigned char sha[SHA_DIGEST_LENGTH];
-#ifndef OPENSSL_NO_SHA256
-        unsigned char sha256[SHA256_DIGEST_LENGTH];
-#endif
-#ifndef OPENSSL_NO_SHA512
-        unsigned char sha512[SHA512_DIGEST_LENGTH];
-#endif
-#endif
-#ifndef OPENSSL_NO_WHIRLPOOL
-        unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
-#endif
-#ifndef OPENSSL_NO_RIPEMD
-        unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
-#endif
+
 #ifndef OPENSSL_NO_RC4
         RC4_KEY rc4_ks;
 #endif
@@ -979,38 +1018,8 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_CAST
         CAST_KEY cast_ks;
 #endif
-        static const unsigned char key16[16] =
-        {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
-        0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12};
-#ifndef OPENSSL_NO_AES
-        static const unsigned char key24[24] =
-        {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
-                0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
-        0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34};
-        static const unsigned char key32[32] =
-        {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
-                0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
-                0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
-        0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56};
-#endif
-#ifndef OPENSSL_NO_CAMELLIA
-        static const unsigned char ckey24[24] =
-        {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
-                0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
-        0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34};
-        static const unsigned char ckey32[32] =
-        {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
-                0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
-                0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
-        0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56};
-#endif
-#ifndef OPENSSL_NO_AES
-#define MAX_BLOCK_SIZE 128
-#else
-#define MAX_BLOCK_SIZE 64
-#endif
         unsigned char DES_iv[8];
-        unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
+        unsigned char iv[2 * 16];
 #ifndef OPENSSL_NO_DES
         static DES_cblock key = {0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0};
         static DES_cblock key2 = {0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12};
@@ -1025,55 +1034,9 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_CAMELLIA
         CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
 #endif
-#define D_MD2           0
-#define D_MD4           1
-#define D_MD5           2
-#define D_HMAC          3
-#define D_SHA1          4
-#define D_RMD160        5
-#define D_RC4           6
-#define D_CBC_DES       7
-#define D_EDE3_DES      8
-#define D_CBC_IDEA      9
-#define D_CBC_SEED      10
-#define D_CBC_RC2       11
-#define D_CBC_RC5       12
-#define D_CBC_BF        13
-#define D_CBC_CAST      14
-#define D_CBC_128_AES   15
-#define D_CBC_192_AES   16
-#define D_CBC_256_AES   17
-#define D_CBC_128_CML   18
-#define D_CBC_192_CML   19
-#define D_CBC_256_CML   20
-#define D_EVP           21
-#define D_SHA256        22
-#define D_SHA512        23
-#define D_WHIRLPOOL     24
-#define D_IGE_128_AES   25
-#define D_IGE_192_AES   26
-#define D_IGE_256_AES   27
-#define D_GHASH         28
-#define D_AES_128_GCM   29
-#define D_AES_256_GCM   30
-#define D_CHACHA20_POLY1305     31
         double d = 0.0;
-        long c[ALGOR_NUM][SIZE_NUM];
-#define R_DSA_512       0
-#define R_DSA_1024      1
-#define R_DSA_2048      2
-#define R_RSA_512       0
-#define R_RSA_1024      1
-#define R_RSA_2048      2
-#define R_RSA_4096      3
-
-#define R_EC_P224    0
-#define R_EC_P256    1
-#define R_EC_P384    2
-#define R_EC_P521    3
 
         RSA *rsa_key[RSA_NUM];
-        long rsa_c[RSA_NUM][2];
         static unsigned int rsa_bits[RSA_NUM] = {512, 1024, 2048, 4096};
         static const unsigned char *rsa_data[RSA_NUM] =
         {test512, test1024, test2048, test4096};
@@ -1081,7 +1044,6 @@ speed_main(int argc, char **argv)
                 sizeof(test512), sizeof(test1024),
         sizeof(test2048), sizeof(test4096)};
         DSA *dsa_key[DSA_NUM];
-        long dsa_c[DSA_NUM][2];
         static unsigned int dsa_bits[DSA_NUM] = {512, 1024, 2048};
 #ifndef OPENSSL_NO_EC
         /*
@@ -1111,14 +1073,12 @@ speed_main(int argc, char **argv)
         unsigned char ecdsasig[256];
         unsigned int ecdsasiglen;
         EC_KEY *ecdsa[EC_NUM];
-        long ecdsa_c[EC_NUM][2];
 
         EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
         unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
         int secret_size_a, secret_size_b;
         int ecdh_checks = 0;
         int secret_idx = 0;
-        long ecdh_c[EC_NUM][2];
 
         int rsa_doit[RSA_NUM];
         int dsa_doit[DSA_NUM];
@@ -1161,7 +1121,6 @@ speed_main(int argc, char **argv)
                 BIO_printf(bio_err, "out of memory\n");
                 goto end;
         }
-        memset(c, 0, sizeof(c));
         memset(DES_iv, 0, sizeof(DES_iv));
         memset(iv, 0, sizeof(iv));
 
@@ -1275,11 +1234,6 @@ speed_main(int argc, char **argv)
                 else
 #endif
 #endif
-#ifndef OPENSSL_NO_WHIRLPOOL
-                if (strcmp(*argv, "whirlpool") == 0)
-                        doit[D_WHIRLPOOL] = 1;
-                else
-#endif
 #ifndef OPENSSL_NO_RIPEMD
                 if (strcmp(*argv, "ripemd") == 0)
                         doit[D_RMD160] = 1;
@@ -1462,16 +1416,12 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_SHA512
                         BIO_printf(bio_err, "sha512   ");
 #endif
-#ifndef OPENSSL_NO_WHIRLPOOL
-                        BIO_printf(bio_err, "whirlpool");
-#endif
 #ifndef OPENSSL_NO_RIPEMD160
                         BIO_printf(bio_err, "rmd160");
 #endif
 #if !defined(OPENSSL_NO_MD2) || \
     !defined(OPENSSL_NO_MD4) || !defined(OPENSSL_NO_MD5) || \
-    !defined(OPENSSL_NO_SHA1) || !defined(OPENSSL_NO_RIPEMD160) || \
-    !defined(OPENSSL_NO_WHIRLPOOL)
+    !defined(OPENSSL_NO_SHA1) || !defined(OPENSSL_NO_RIPEMD160)
                         BIO_printf(bio_err, "\n");
 #endif
 
@@ -1602,8 +1552,8 @@ speed_main(int argc, char **argv)
 #endif
 #ifndef OPENSSL_NO_CAMELLIA
         Camellia_set_key(key16, 128, &camellia_ks1);
-        Camellia_set_key(ckey24, 192, &camellia_ks2);
-        Camellia_set_key(ckey32, 256, &camellia_ks3);
+        Camellia_set_key(key24, 192, &camellia_ks2);
+        Camellia_set_key(key32, 256, &camellia_ks3);
 #endif
 #ifndef OPENSSL_NO_IDEA
         idea_set_encrypt_key(key16, &idea_ks);
@@ -1620,8 +1570,7 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_CAST
         CAST_set_key(&cast_ks, 16, key16);
 #endif
-        memset(rsa_c, 0, sizeof(rsa_c));
-#define COND(c) (run && count<0x7fffffff)
+#define COND    (run && count<0x7fffffff)
 #define COUNT(d) (count)
 
         memset(&sa, 0, sizeof(sa));
@@ -1633,11 +1582,11 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_MD4
         if (doit[D_MD4]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
-                                EVP_Digest(&(buf[0]), (unsigned long) lengths[j], &(md4[0]), NULL, EVP_md4(), NULL);
-                        d = Time_F(STOP);
+                        print_message(names[D_MD4], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
+                                EVP_Digest(&(buf[0]), (unsigned long) lengths[j], md, NULL, EVP_md4(), NULL);
+                        d = time_f(STOP);
                         print_result(D_MD4, j, count, d);
                 }
         }
@@ -1646,17 +1595,17 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_MD5
         if (doit[D_MD5]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
-                                EVP_Digest(&(buf[0]), (unsigned long) lengths[j], &(md5[0]), NULL, EVP_get_digestbyname("md5"), NULL);
-                        d = Time_F(STOP);
+                        print_message(names[D_MD5], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
+                                EVP_Digest(&(buf[0]), (unsigned long) lengths[j], md, NULL, EVP_get_digestbyname("md5"), NULL);
+                        d = time_f(STOP);
                         print_result(D_MD5, j, count, d);
                 }
         }
 #endif
 
-#if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_HMAC)
+#if !defined(OPENSSL_NO_SHA256) && !defined(OPENSSL_NO_HMAC)
         if (doit[D_HMAC]) {
                 HMAC_CTX *hctx;
 
@@ -1666,12 +1615,12 @@ speed_main(int argc, char **argv)
                 }
 
                 HMAC_Init_ex(hctx, (unsigned char *) "This is a key...",
-                    16, EVP_md5(), NULL);
+                    16, EVP_sha256(), NULL);
 
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
+                        print_message(names[D_HMAC], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++) {
                                 if (!HMAC_Init_ex(hctx, NULL, 0, NULL, NULL)) {
                                         HMAC_CTX_free(hctx);
                                         goto end;
@@ -1680,12 +1629,12 @@ speed_main(int argc, char **argv)
                                         HMAC_CTX_free(hctx);
                                         goto end;
                                 }
-                                if (!HMAC_Final(hctx, &(hmac[0]), NULL)) {
+                                if (!HMAC_Final(hctx, md, NULL)) {
                                         HMAC_CTX_free(hctx);
                                         goto end;
                                 }
                         }
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_HMAC, j, count, d);
                 }
                 HMAC_CTX_free(hctx);
@@ -1694,22 +1643,22 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_SHA
         if (doit[D_SHA1]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
-                                EVP_Digest(buf, (unsigned long) lengths[j], &(sha[0]), NULL, EVP_sha1(), NULL);
-                        d = Time_F(STOP);
+                        print_message(names[D_SHA1], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
+                                EVP_Digest(buf, (unsigned long) lengths[j], md, NULL, EVP_sha1(), NULL);
+                        d = time_f(STOP);
                         print_result(D_SHA1, j, count, d);
                 }
         }
 #ifndef OPENSSL_NO_SHA256
         if (doit[D_SHA256]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
-                                SHA256(buf, lengths[j], sha256);
-                        d = Time_F(STOP);
+                        print_message(names[D_SHA256], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
+                                SHA256(buf, lengths[j], md);
+                        d = time_f(STOP);
                         print_result(D_SHA256, j, count, d);
                 }
         }
@@ -1718,38 +1667,25 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_SHA512
         if (doit[D_SHA512]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
-                                SHA512(buf, lengths[j], sha512);
-                        d = Time_F(STOP);
+                        print_message(names[D_SHA512], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
+                                SHA512(buf, lengths[j], md);
+                        d = time_f(STOP);
                         print_result(D_SHA512, j, count, d);
                 }
         }
 #endif
 #endif
 
-#ifndef OPENSSL_NO_WHIRLPOOL
-        if (doit[D_WHIRLPOOL]) {
-                for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
-                                WHIRLPOOL(buf, lengths[j], whirlpool);
-                        d = Time_F(STOP);
-                        print_result(D_WHIRLPOOL, j, count, d);
-                }
-        }
-#endif
-
 #ifndef OPENSSL_NO_RIPEMD
         if (doit[D_RMD160]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
-                                EVP_Digest(buf, (unsigned long) lengths[j], &(rmd160[0]), NULL, EVP_ripemd160(), NULL);
-                        d = Time_F(STOP);
+                        print_message(names[D_RMD160], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
+                                EVP_Digest(buf, (unsigned long) lengths[j], md, NULL, EVP_ripemd160(), NULL);
+                        d = time_f(STOP);
                         print_result(D_RMD160, j, count, d);
                 }
         }
@@ -1757,12 +1693,12 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_RC4
         if (doit[D_RC4]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
+                        print_message(names[D_RC4], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 RC4(&rc4_ks, (unsigned int) lengths[j],
                                     buf, buf);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_RC4, j, count, d);
                 }
         }
@@ -1770,24 +1706,24 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_DES
         if (doit[D_CBC_DES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
+                        print_message(names[D_CBC_DES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
                                     &DES_iv, DES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_DES, j, count, d);
                 }
         }
         if (doit[D_EDE3_DES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
+                        print_message(names[D_EDE3_DES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
                                     &sch, &sch2, &sch3,
                                     &DES_iv, DES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_EDE3_DES, j, count, d);
                 }
         }
@@ -1795,73 +1731,73 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_AES
         if (doit[D_CBC_128_AES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
+                        print_message(names[D_CBC_128_AES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 AES_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &aes_ks1,
                                     iv, AES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_128_AES, j, count, d);
                 }
         }
         if (doit[D_CBC_192_AES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
+                        print_message(names[D_CBC_192_AES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 AES_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &aes_ks2,
                                     iv, AES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_192_AES, j, count, d);
                 }
         }
         if (doit[D_CBC_256_AES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
+                        print_message(names[D_CBC_256_AES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 AES_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &aes_ks3,
                                     iv, AES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_256_AES, j, count, d);
                 }
         }
         if (doit[D_IGE_128_AES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
+                        print_message(names[D_IGE_128_AES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 AES_ige_encrypt(buf, buf2,
                                     (unsigned long) lengths[j], &aes_ks1,
                                     iv, AES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_IGE_128_AES, j, count, d);
                 }
         }
         if (doit[D_IGE_192_AES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
+                        print_message(names[D_IGE_192_AES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 AES_ige_encrypt(buf, buf2,
                                     (unsigned long) lengths[j], &aes_ks2,
                                     iv, AES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_IGE_192_AES, j, count, d);
                 }
         }
         if (doit[D_IGE_256_AES]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
+                        print_message(names[D_IGE_256_AES], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 AES_ige_encrypt(buf, buf2,
                                     (unsigned long) lengths[j], &aes_ks3,
                                     iv, AES_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_IGE_256_AES, j, count, d);
                 }
         }
@@ -1870,11 +1806,11 @@ speed_main(int argc, char **argv)
                 CRYPTO_gcm128_setiv(ctx, (unsigned char *) "0123456789ab", 12);
 
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
+                        print_message(names[D_GHASH], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_GHASH, j, count, d);
                 }
                 CRYPTO_gcm128_release(ctx);
@@ -1896,12 +1832,12 @@ speed_main(int argc, char **argv)
                 nonce_len = EVP_AEAD_nonce_length(aead);
 
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_AES_128_GCM],c[D_AES_128_GCM][j],lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_AES_128_GCM][j]); count++)
+                        print_message(names[D_AES_128_GCM], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 EVP_AEAD_CTX_seal(ctx, buf, &buf_len, BUFSIZE, nonce,
                                     nonce_len, buf, lengths[j], NULL, 0);
-                        d=Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_AES_128_GCM,j,count,d);
                 }
                 EVP_AEAD_CTX_free(ctx);
@@ -1924,12 +1860,12 @@ speed_main(int argc, char **argv)
                 nonce_len = EVP_AEAD_nonce_length(aead);
 
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_AES_256_GCM],c[D_AES_256_GCM][j],lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_AES_256_GCM][j]); count++)
+                        print_message(names[D_AES_256_GCM], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 EVP_AEAD_CTX_seal(ctx, buf, &buf_len, BUFSIZE, nonce,
                                     nonce_len, buf, lengths[j], NULL, 0);
-                        d=Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_AES_256_GCM, j, count, d);
                 }
                 EVP_AEAD_CTX_free(ctx);
@@ -1953,13 +1889,12 @@ speed_main(int argc, char **argv)
                 nonce_len = EVP_AEAD_nonce_length(aead);
 
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CHACHA20_POLY1305],
-                            c[D_CHACHA20_POLY1305][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CHACHA20_POLY1305][j]); count++)
+                        print_message(names[D_CHACHA20_POLY1305], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 EVP_AEAD_CTX_seal(ctx, buf, &buf_len, BUFSIZE, nonce,
                                     nonce_len, buf, lengths[j], NULL, 0);
-                        d=Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CHACHA20_POLY1305, j, count, d);
                 }
                 EVP_AEAD_CTX_free(ctx);
@@ -1968,37 +1903,37 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_CAMELLIA
         if (doit[D_CBC_128_CML]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
+                        print_message(names[D_CBC_128_CML], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 Camellia_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &camellia_ks1,
                                     iv, CAMELLIA_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_128_CML, j, count, d);
                 }
         }
         if (doit[D_CBC_192_CML]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
+                        print_message(names[D_CBC_192_CML], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 Camellia_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &camellia_ks2,
                                     iv, CAMELLIA_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_192_CML, j, count, d);
                 }
         }
         if (doit[D_CBC_256_CML]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
+                        print_message(names[D_CBC_256_CML], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 Camellia_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &camellia_ks3,
                                     iv, CAMELLIA_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_256_CML, j, count, d);
                 }
         }
@@ -2006,13 +1941,13 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_IDEA
         if (doit[D_CBC_IDEA]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
+                        print_message(names[D_CBC_IDEA], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 idea_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &idea_ks,
                                     iv, IDEA_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_IDEA, j, count, d);
                 }
         }
@@ -2020,13 +1955,13 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_RC2
         if (doit[D_CBC_RC2]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
+                        print_message(names[D_CBC_RC2], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 RC2_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &rc2_ks,
                                     iv, RC2_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_RC2, j, count, d);
                 }
         }
@@ -2034,13 +1969,13 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_BF
         if (doit[D_CBC_BF]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
+                        print_message(names[D_CBC_BF], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 BF_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &bf_ks,
                                     iv, BF_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_BF, j, count, d);
                 }
         }
@@ -2048,13 +1983,13 @@ speed_main(int argc, char **argv)
 #ifndef OPENSSL_NO_CAST
         if (doit[D_CBC_CAST]) {
                 for (j = 0; j < SIZE_NUM; j++) {
-                        print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
+                        print_message(names[D_CBC_CAST], lengths[j]);
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++)
                                 CAST_cbc_encrypt(buf, buf,
                                     (unsigned long) lengths[j], &cast_ks,
                                     iv, CAST_ENCRYPT);
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         print_result(D_CBC_CAST, j, count, d);
                 }
         }
@@ -2073,8 +2008,7 @@ speed_main(int argc, char **argv)
                                  * optimization here!  names[D_EVP] somehow
                                  * becomes NULL
                                  */
-                                print_message(names[D_EVP], save_count,
-                                    lengths[j]);
+                                print_message(names[D_EVP], lengths[j]);
 
                                 if ((ctx = EVP_CIPHER_CTX_new()) == NULL) {
                                         BIO_printf(bio_err, "Failed to "
@@ -2087,30 +2021,29 @@ speed_main(int argc, char **argv)
                                         EVP_EncryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
                                 EVP_CIPHER_CTX_set_padding(ctx, 0);
 
-                                Time_F(START);
+                                time_f(START);
                                 if (decrypt)
-                                        for (count = 0, run = 1; COND(save_count * 4 * lengths[0] / lengths[j]); count++)
+                                        for (count = 0, run = 1; COND; count++)
                                                 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[j]);
                                 else
-                                        for (count = 0, run = 1; COND(save_count * 4 * lengths[0] / lengths[j]); count++)
+                                        for (count = 0, run = 1; COND; count++)
                                                 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[j]);
                                 if (decrypt)
                                         EVP_DecryptFinal_ex(ctx, buf, &outl);
                                 else
                                         EVP_EncryptFinal_ex(ctx, buf, &outl);
-                                d = Time_F(STOP);
+                                d = time_f(STOP);
                                 EVP_CIPHER_CTX_free(ctx);
                         }
                         if (evp_md) {
                                 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
-                                print_message(names[D_EVP], save_count,
-                                    lengths[j]);
+                                print_message(names[D_EVP], lengths[j]);
 
-                                Time_F(START);
-                                for (count = 0, run = 1; COND(save_count * 4 * lengths[0] / lengths[j]); count++)
+                                time_f(START);
+                                for (count = 0, run = 1; COND; count++)
                                         EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
 
-                                d = Time_F(STOP);
+                                d = time_f(STOP);
                         }
                         print_result(D_EVP, j, count, d);
                 }
@@ -2127,11 +2060,11 @@ speed_main(int argc, char **argv)
                         rsa_count = 1;
                 } else {
                         pkey_print_message("private", "rsa",
-                            rsa_c[j][0], rsa_bits[j],
+                            rsa_bits[j],
                             RSA_SECONDS);
 /*                      RSA_blinding_on(rsa_key[j],NULL); */
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++) {
                                 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2,
                                     &rsa_num, rsa_key[j]);
                                 if (ret == 0) {
@@ -2142,7 +2075,7 @@ speed_main(int argc, char **argv)
                                         break;
                                 }
                         }
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         BIO_printf(bio_err, mr ? "+R1:%ld:%d:%.2f\n"
                             : "%ld %d bit private RSA in %.2fs\n",
                             count, rsa_bits[j], d);
@@ -2157,10 +2090,10 @@ speed_main(int argc, char **argv)
                         rsa_doit[j] = 0;
                 } else {
                         pkey_print_message("public", "rsa",
-                            rsa_c[j][1], rsa_bits[j],
+                            rsa_bits[j],
                             RSA_SECONDS);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++) {
                                 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2,
                                     rsa_num, rsa_key[j]);
                                 if (ret <= 0) {
@@ -2171,7 +2104,7 @@ speed_main(int argc, char **argv)
                                         break;
                                 }
                         }
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         BIO_printf(bio_err, mr ? "+R2:%ld:%d:%.2f\n"
                             : "%ld %d bit public RSA in %.2fs\n",
                             count, rsa_bits[j], d);
@@ -2202,10 +2135,10 @@ speed_main(int argc, char **argv)
                         rsa_count = 1;
                 } else {
                         pkey_print_message("sign", "dsa",
-                            dsa_c[j][0], dsa_bits[j],
+                            dsa_bits[j],
                             DSA_SECONDS);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++) {
                                 ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2,
                                     &kk, dsa_key[j]);
                                 if (ret == 0) {
@@ -2216,7 +2149,7 @@ speed_main(int argc, char **argv)
                                         break;
                                 }
                         }
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         BIO_printf(bio_err, mr ? "+R3:%ld:%d:%.2f\n"
                             : "%ld %d bit DSA signs in %.2fs\n",
                             count, dsa_bits[j], d);
@@ -2232,10 +2165,10 @@ speed_main(int argc, char **argv)
                         dsa_doit[j] = 0;
                 } else {
                         pkey_print_message("verify", "dsa",
-                            dsa_c[j][1], dsa_bits[j],
+                            dsa_bits[j],
                             DSA_SECONDS);
-                        Time_F(START);
-                        for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
+                        time_f(START);
+                        for (count = 0, run = 1; COND; count++) {
                                 ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2,
                                     kk, dsa_key[j]);
                                 if (ret <= 0) {
@@ -2246,7 +2179,7 @@ speed_main(int argc, char **argv)
                                         break;
                                 }
                         }
-                        d = Time_F(STOP);
+                        d = time_f(STOP);
                         BIO_printf(bio_err, mr ? "+R4:%ld:%d:%.2f\n"
                             : "%ld %d bit DSA verify in %.2fs\n",
                             count, dsa_bits[j], d);
@@ -2283,13 +2216,11 @@ speed_main(int argc, char **argv)
                                 rsa_count = 1;
                         } else {
                                 pkey_print_message("sign", "ecdsa",
-                                    ecdsa_c[j][0],
                                     test_curves_bits[j],
                                     ECDSA_SECONDS);
 
-                                Time_F(START);
-                                for (count = 0, run = 1; COND(ecdsa_c[j][0]);
-                                    count++) {
+                                time_f(START);
+                                for (count = 0, run = 1; COND; count++) {
                                         ret = ECDSA_sign(0, buf, 20,
                                             ecdsasig, &ecdsasiglen,
                                             ecdsa[j]);
@@ -2300,7 +2231,7 @@ speed_main(int argc, char **argv)
                                                 break;
                                         }
                                 }
-                                d = Time_F(STOP);
+                                d = time_f(STOP);
 
                                 BIO_printf(bio_err, mr ? "+R5:%ld:%d:%.2f\n" :
                                     "%ld %d bit ECDSA signs in %.2fs \n",
@@ -2318,11 +2249,10 @@ speed_main(int argc, char **argv)
                                 ecdsa_doit[j] = 0;
                         } else {
                                 pkey_print_message("verify", "ecdsa",
-                                    ecdsa_c[j][1],
                                     test_curves_bits[j],
                                     ECDSA_SECONDS);
-                                Time_F(START);
-                                for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
+                                time_f(START);
+                                for (count = 0, run = 1; COND; count++) {
                                         ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
                                         if (ret != 1) {
                                                 BIO_printf(bio_err, "ECDSA verify failure\n");
@@ -2331,7 +2261,7 @@ speed_main(int argc, char **argv)
                                                 break;
                                         }
                                 }
-                                d = Time_F(STOP);
+                                d = time_f(STOP);
                                 BIO_printf(bio_err, mr ? "+R6:%ld:%d:%.2f\n"
                                     : "%ld %d bit ECDSA verify in %.2fs\n",
                                     count, test_curves_bits[j], d);
@@ -2405,18 +2335,16 @@ speed_main(int argc, char **argv)
                                         rsa_count = 1;
                                 } else {
                                         pkey_print_message("", "ecdh",
-                                            ecdh_c[j][0],
                                             test_curves_bits[j],
                                             ECDH_SECONDS);
-                                        Time_F(START);
-                                        for (count = 0, run = 1;
-                                             COND(ecdh_c[j][0]); count++) {
+                                        time_f(START);
+                                        for (count = 0, run = 1; COND; count++) {
                                                 ECDH_compute_key(secret_a,
                                                     outlen,
                                                     EC_KEY_get0_public_key(ecdh_b[j]),
                                                     ecdh_a[j], kdf);
                                         }
-                                        d = Time_F(STOP);
+                                        d = time_f(STOP);
                                         BIO_printf(bio_err, mr
                                             ? "+R7:%ld:%d:%.2f\n"
                                             : "%ld %d-bit ECDH ops in %.2fs\n",
@@ -2569,7 +2497,7 @@ show_res:
 }
 
 static void
-print_message(const char *s, long num, int length)
+print_message(const char *s, int length)
 {
         BIO_printf(bio_err, mr ? "+DT:%s:%d:%d\n"
             : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
@@ -2578,7 +2506,7 @@ print_message(const char *s, long num, int length)
 }
 
 static void
-pkey_print_message(const char *str, const char *str2, long num,
+pkey_print_message(const char *str, const char *str2,
     int bits, int tm)
 {
         BIO_printf(bio_err, mr ? "+DTP:%d:%s:%s:%d\n"