From: tb <tb@openbsd.org>
Date: Thu, 16 Feb 2023 08:38:17 +0000 (+0000)
Subject: libressl *_namespace.h: adjust *_ALIAS() to require a semicolon
X-Git-Url: http://artulab.com/gitweb/?a=commitdiff_plain;h=cedac4184d41cfc52c913dbb6c371cdbae931594;p=openbsd

libressl *_namespace.h: adjust *_ALIAS() to require a semicolon

LCRYPTO_ALIAS() and LSSL_ALIAS() contained a trailing semicolon.
This does not conform to style(9), breaks editors and ctags and
(most importantly) my workflow. Fix this by neutering them with
asm("") so that -Wpedantic doesn't complain. There's precedent
in libc's namespace.h

fix suggested by & ok jsing
---

diff --git a/lib/libcrypto/hidden/crypto_namespace.h b/lib/libcrypto/hidden/crypto_namespace.h
index 6ceef26e2d8..5bf9b4d4da7 100644
--- a/lib/libcrypto/hidden/crypto_namespace.h
+++ b/lib/libcrypto/hidden/crypto_namespace.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: crypto_namespace.h,v 1.1 2022/11/11 11:25:18 beck Exp $	*/
+/*	$OpenBSD: crypto_namespace.h,v 1.2 2023/02/16 08:38:17 tb Exp $	*/
 /*
  * Copyright (c) 2016 Philip Guenther <guenther@openbsd.org>
  *
@@ -30,7 +30,7 @@
 #  define LCRYPTO_USED(x)		__attribute__((visibility("hidden")))	\
 				typeof(x) x asm("_lcry_"#x)
 #  define LCRYPTO_ALIAS1(pre,x)	asm(".global "#pre#x"; "#pre#x" = _lcry_"#x)
-#  define LCRYPTO_ALIAS(x)	LCRYPTO_ALIAS1(,x); LCRYPTO_ALIAS1(_libre_,x);
+#  define LCRYPTO_ALIAS(x)	LCRYPTO_ALIAS1(,x); LCRYPTO_ALIAS1(_libre_,x)
 #else
 #  define LCRYPTO_USED(x)          typeof(x) x asm("_libre_"#x)
 #endif
@@ -38,7 +38,7 @@
 # define LCRYPTO_UNUSED(x)
 # define LCRYPTO_USED(x)
 # define LCRYPTO_ALIAS1(pre,x)
-# define LCRYPTO_ALIAS(x)
+# define LCRYPTO_ALIAS(x)	asm("")
 #endif
 
 #endif	/* _LIBCRYPTO_CRYPTO_NAMESPACE_H_ */
diff --git a/lib/libcrypto/hmac/hmac.c b/lib/libcrypto/hmac/hmac.c
index 047b67b9ea2..ea3a1b4a45f 100644
--- a/lib/libcrypto/hmac/hmac.c
+++ b/lib/libcrypto/hmac/hmac.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: hmac.c,v 1.30 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: hmac.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -134,7 +134,7 @@ HMAC_Init_ex(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md,
 err:
 	return 0;
 }
-LCRYPTO_ALIAS(HMAC_Init_ex)
+LCRYPTO_ALIAS(HMAC_Init_ex);
 
 int
 HMAC_Init(HMAC_CTX *ctx, const void *key, int len, const EVP_MD *md)
@@ -152,7 +152,7 @@ HMAC_Update(HMAC_CTX *ctx, const unsigned char *data, size_t len)
 
 	return EVP_DigestUpdate(&ctx->md_ctx, data, len);
 }
-LCRYPTO_ALIAS(HMAC_Update)
+LCRYPTO_ALIAS(HMAC_Update);
 
 int
 HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
@@ -175,7 +175,7 @@ HMAC_Final(HMAC_CTX *ctx, unsigned char *md, unsigned int *len)
 err:
 	return 0;
 }
-LCRYPTO_ALIAS(HMAC_Final)
+LCRYPTO_ALIAS(HMAC_Final);
 
 HMAC_CTX *
 HMAC_CTX_new(void)
@@ -189,7 +189,7 @@ HMAC_CTX_new(void)
 
 	return ctx;
 }
-LCRYPTO_ALIAS(HMAC_CTX_new)
+LCRYPTO_ALIAS(HMAC_CTX_new);
 
 void
 HMAC_CTX_free(HMAC_CTX *ctx)
@@ -201,7 +201,7 @@ HMAC_CTX_free(HMAC_CTX *ctx)
 
 	free(ctx);
 }
-LCRYPTO_ALIAS(HMAC_CTX_free)
+LCRYPTO_ALIAS(HMAC_CTX_free);
 
 int
 HMAC_CTX_reset(HMAC_CTX *ctx)
@@ -236,7 +236,7 @@ HMAC_CTX_copy(HMAC_CTX *dctx, HMAC_CTX *sctx)
 err:
 	return 0;
 }
-LCRYPTO_ALIAS(HMAC_CTX_copy)
+LCRYPTO_ALIAS(HMAC_CTX_copy);
 
 void
 HMAC_CTX_cleanup(HMAC_CTX *ctx)
@@ -254,14 +254,14 @@ HMAC_CTX_set_flags(HMAC_CTX *ctx, unsigned long flags)
 	EVP_MD_CTX_set_flags(&ctx->o_ctx, flags);
 	EVP_MD_CTX_set_flags(&ctx->md_ctx, flags);
 }
-LCRYPTO_ALIAS(HMAC_CTX_set_flags)
+LCRYPTO_ALIAS(HMAC_CTX_set_flags);
 
 const EVP_MD *
 HMAC_CTX_get_md(const HMAC_CTX *ctx)
 {
 	return ctx->md;
 }
-LCRYPTO_ALIAS(HMAC_CTX_get_md)
+LCRYPTO_ALIAS(HMAC_CTX_get_md);
 
 unsigned char *
 HMAC(const EVP_MD *evp_md, const void *key, int key_len, const unsigned char *d,
@@ -290,4 +290,4 @@ err:
 	HMAC_CTX_cleanup(&c);
 	return NULL;
 }
-LCRYPTO_ALIAS(HMAC)
+LCRYPTO_ALIAS(HMAC);
diff --git a/lib/libcrypto/pkcs12/p12_add.c b/lib/libcrypto/pkcs12/p12_add.c
index 66cb95b1dbf..93c7c7221e1 100644
--- a/lib/libcrypto/pkcs12/p12_add.c
+++ b/lib/libcrypto/pkcs12/p12_add.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_add.c,v 1.21 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_add.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -90,7 +90,7 @@ PKCS12_item_pack_safebag(void *obj, const ASN1_ITEM *it, int nid1, int nid2)
 	safebag->type = OBJ_nid2obj(nid2);
 	return safebag;
 }
-LCRYPTO_ALIAS(PKCS12_item_pack_safebag)
+LCRYPTO_ALIAS(PKCS12_item_pack_safebag);
 
 /* Turn a stack of SAFEBAGS into a PKCS#7 data Contentinfo */
 PKCS7 *
@@ -118,7 +118,7 @@ err:
 	PKCS7_free(p7);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_pack_p7data)
+LCRYPTO_ALIAS(PKCS12_pack_p7data);
 
 /* Unpack SAFEBAGS from PKCS#7 data ContentInfo */
 STACK_OF(PKCS12_SAFEBAG) *
@@ -130,7 +130,7 @@ PKCS12_unpack_p7data(PKCS7 *p7)
 	}
 	return ASN1_item_unpack(p7->d.data, &PKCS12_SAFEBAGS_it);
 }
-LCRYPTO_ALIAS(PKCS12_unpack_p7data)
+LCRYPTO_ALIAS(PKCS12_unpack_p7data);
 
 /* Turn a stack of SAFEBAGS into a PKCS#7 encrypted data ContentInfo */
 
@@ -177,7 +177,7 @@ err:
 	PKCS7_free(p7);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_pack_p7encdata)
+LCRYPTO_ALIAS(PKCS12_pack_p7encdata);
 
 STACK_OF(PKCS12_SAFEBAG) *
 PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, int passlen)
@@ -188,14 +188,14 @@ PKCS12_unpack_p7encdata(PKCS7 *p7, const char *pass, int passlen)
 	    &PKCS12_SAFEBAGS_it, pass, passlen,
 	    p7->d.encrypted->enc_data->enc_data, 1);
 }
-LCRYPTO_ALIAS(PKCS12_unpack_p7encdata)
+LCRYPTO_ALIAS(PKCS12_unpack_p7encdata);
 
 PKCS8_PRIV_KEY_INFO *
 PKCS12_decrypt_skey(const PKCS12_SAFEBAG *bag, const char *pass, int passlen)
 {
 	return PKCS8_decrypt(bag->value.shkeybag, pass, passlen);
 }
-LCRYPTO_ALIAS(PKCS12_decrypt_skey)
+LCRYPTO_ALIAS(PKCS12_decrypt_skey);
 
 int
 PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes)
@@ -205,7 +205,7 @@ PKCS12_pack_authsafes(PKCS12 *p12, STACK_OF(PKCS7) *safes)
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS12_pack_authsafes)
+LCRYPTO_ALIAS(PKCS12_pack_authsafes);
 
 STACK_OF(PKCS7) *
 PKCS12_unpack_authsafes(const PKCS12 *p12)
@@ -217,4 +217,4 @@ PKCS12_unpack_authsafes(const PKCS12 *p12)
 	return ASN1_item_unpack(p12->authsafes->d.data,
 	    &PKCS12_AUTHSAFES_it);
 }
-LCRYPTO_ALIAS(PKCS12_unpack_authsafes)
+LCRYPTO_ALIAS(PKCS12_unpack_authsafes);
diff --git a/lib/libcrypto/pkcs12/p12_asn.c b/lib/libcrypto/pkcs12/p12_asn.c
index c45482d5f13..a9decccb5b3 100644
--- a/lib/libcrypto/pkcs12/p12_asn.c
+++ b/lib/libcrypto/pkcs12/p12_asn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_asn.c,v 1.13 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_asn.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -106,28 +106,28 @@ d2i_PKCS12(PKCS12 **a, const unsigned char **in, long len)
 	return (PKCS12 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS12_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS12)
+LCRYPTO_ALIAS(d2i_PKCS12);
 
 int
 i2d_PKCS12(PKCS12 *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS12)
+LCRYPTO_ALIAS(i2d_PKCS12);
 
 PKCS12 *
 PKCS12_new(void)
 {
 	return (PKCS12 *)ASN1_item_new(&PKCS12_it);
 }
-LCRYPTO_ALIAS(PKCS12_new)
+LCRYPTO_ALIAS(PKCS12_new);
 
 void
 PKCS12_free(PKCS12 *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_it);
 }
-LCRYPTO_ALIAS(PKCS12_free)
+LCRYPTO_ALIAS(PKCS12_free);
 
 static const ASN1_TEMPLATE PKCS12_MAC_DATA_seq_tt[] = {
 	{
@@ -170,28 +170,28 @@ d2i_PKCS12_MAC_DATA(PKCS12_MAC_DATA **a, const unsigned char **in, long len)
 	return (PKCS12_MAC_DATA *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS12_MAC_DATA_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS12_MAC_DATA)
+LCRYPTO_ALIAS(d2i_PKCS12_MAC_DATA);
 
 int
 i2d_PKCS12_MAC_DATA(PKCS12_MAC_DATA *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_MAC_DATA_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS12_MAC_DATA)
+LCRYPTO_ALIAS(i2d_PKCS12_MAC_DATA);
 
 PKCS12_MAC_DATA *
 PKCS12_MAC_DATA_new(void)
 {
 	return (PKCS12_MAC_DATA *)ASN1_item_new(&PKCS12_MAC_DATA_it);
 }
-LCRYPTO_ALIAS(PKCS12_MAC_DATA_new)
+LCRYPTO_ALIAS(PKCS12_MAC_DATA_new);
 
 void
 PKCS12_MAC_DATA_free(PKCS12_MAC_DATA *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_MAC_DATA_it);
 }
-LCRYPTO_ALIAS(PKCS12_MAC_DATA_free)
+LCRYPTO_ALIAS(PKCS12_MAC_DATA_free);
 
 static const ASN1_TEMPLATE bag_default_tt = {
 	.flags = ASN1_TFLG_EXPLICIT,
@@ -280,28 +280,28 @@ d2i_PKCS12_BAGS(PKCS12_BAGS **a, const unsigned char **in, long len)
 	return (PKCS12_BAGS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS12_BAGS_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS12_BAGS)
+LCRYPTO_ALIAS(d2i_PKCS12_BAGS);
 
 int
 i2d_PKCS12_BAGS(PKCS12_BAGS *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_BAGS_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS12_BAGS)
+LCRYPTO_ALIAS(i2d_PKCS12_BAGS);
 
 PKCS12_BAGS *
 PKCS12_BAGS_new(void)
 {
 	return (PKCS12_BAGS *)ASN1_item_new(&PKCS12_BAGS_it);
 }
-LCRYPTO_ALIAS(PKCS12_BAGS_new)
+LCRYPTO_ALIAS(PKCS12_BAGS_new);
 
 void
 PKCS12_BAGS_free(PKCS12_BAGS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_BAGS_it);
 }
-LCRYPTO_ALIAS(PKCS12_BAGS_free)
+LCRYPTO_ALIAS(PKCS12_BAGS_free);
 
 static const ASN1_TEMPLATE safebag_default_tt = {
 	.flags = ASN1_TFLG_EXPLICIT,
@@ -429,28 +429,28 @@ d2i_PKCS12_SAFEBAG(PKCS12_SAFEBAG **a, const unsigned char **in, long len)
 	return (PKCS12_SAFEBAG *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS12_SAFEBAG_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS12_SAFEBAG)
+LCRYPTO_ALIAS(d2i_PKCS12_SAFEBAG);
 
 int
 i2d_PKCS12_SAFEBAG(PKCS12_SAFEBAG *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS12_SAFEBAG_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS12_SAFEBAG)
+LCRYPTO_ALIAS(i2d_PKCS12_SAFEBAG);
 
 PKCS12_SAFEBAG *
 PKCS12_SAFEBAG_new(void)
 {
 	return (PKCS12_SAFEBAG *)ASN1_item_new(&PKCS12_SAFEBAG_it);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_new)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_new);
 
 void
 PKCS12_SAFEBAG_free(PKCS12_SAFEBAG *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS12_SAFEBAG_it);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_free)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_free);
 
 /* SEQUENCE OF SafeBag */
 static const ASN1_TEMPLATE PKCS12_SAFEBAGS_item_tt = {
diff --git a/lib/libcrypto/pkcs12/p12_attr.c b/lib/libcrypto/pkcs12/p12_attr.c
index e1635ea038a..d43b205a07f 100644
--- a/lib/libcrypto/pkcs12/p12_attr.c
+++ b/lib/libcrypto/pkcs12/p12_attr.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_attr.c,v 1.19 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_attr.c,v 1.20 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -74,7 +74,7 @@ PKCS12_add_localkeyid(PKCS12_SAFEBAG *bag, unsigned char *name, int namelen)
 	else
 		return 0;
 }
-LCRYPTO_ALIAS(PKCS12_add_localkeyid)
+LCRYPTO_ALIAS(PKCS12_add_localkeyid);
 
 /* Add key usage to PKCS#8 structure */
 
@@ -86,7 +86,7 @@ PKCS8_add_keyusage(PKCS8_PRIV_KEY_INFO *p8, int usage)
 	return PKCS8_pkey_add1_attr_by_NID(p8, NID_key_usage, V_ASN1_BIT_STRING,
 	    &us_val, 1);
 }
-LCRYPTO_ALIAS(PKCS8_add_keyusage)
+LCRYPTO_ALIAS(PKCS8_add_keyusage);
 
 /* Add a friendlyname to a safebag */
 
@@ -99,7 +99,7 @@ PKCS12_add_friendlyname_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen)
 	else
 		return 0;
 }
-LCRYPTO_ALIAS(PKCS12_add_friendlyname_asc)
+LCRYPTO_ALIAS(PKCS12_add_friendlyname_asc);
 
 
 int
@@ -112,7 +112,7 @@ PKCS12_add_friendlyname_uni(PKCS12_SAFEBAG *bag, const unsigned char *name,
 	else
 		return 0;
 }
-LCRYPTO_ALIAS(PKCS12_add_friendlyname_uni)
+LCRYPTO_ALIAS(PKCS12_add_friendlyname_uni);
 
 int
 PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen)
@@ -123,7 +123,7 @@ PKCS12_add_CSPName_asc(PKCS12_SAFEBAG *bag, const char *name, int namelen)
 	else
 		return 0;
 }
-LCRYPTO_ALIAS(PKCS12_add_CSPName_asc)
+LCRYPTO_ALIAS(PKCS12_add_CSPName_asc);
 
 ASN1_TYPE *
 PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid)
@@ -140,7 +140,7 @@ PKCS12_get_attr_gen(const STACK_OF(X509_ATTRIBUTE) *attrs, int attr_nid)
 	}
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_get_attr_gen)
+LCRYPTO_ALIAS(PKCS12_get_attr_gen);
 
 char *
 PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag)
@@ -154,11 +154,11 @@ PKCS12_get_friendlyname(PKCS12_SAFEBAG *bag)
 	return OPENSSL_uni2asc(atype->value.bmpstring->data,
 	    atype->value.bmpstring->length);
 }
-LCRYPTO_ALIAS(PKCS12_get_friendlyname)
+LCRYPTO_ALIAS(PKCS12_get_friendlyname);
 
 const STACK_OF(X509_ATTRIBUTE) *
 PKCS12_SAFEBAG_get0_attrs(const PKCS12_SAFEBAG *bag)
 {
 	return bag->attrib;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attrs)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attrs);
diff --git a/lib/libcrypto/pkcs12/p12_crpt.c b/lib/libcrypto/pkcs12/p12_crpt.c
index 63474621cb7..e7d30101c36 100644
--- a/lib/libcrypto/pkcs12/p12_crpt.c
+++ b/lib/libcrypto/pkcs12/p12_crpt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_crpt.c,v 1.16 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_crpt.c,v 1.17 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -68,7 +68,7 @@ void
 PKCS12_PBE_add(void)
 {
 }
-LCRYPTO_ALIAS(PKCS12_PBE_add)
+LCRYPTO_ALIAS(PKCS12_PBE_add);
 
 int
 PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
@@ -120,4 +120,4 @@ PKCS12_PBE_keyivgen(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 	explicit_bzero(iv, EVP_MAX_IV_LENGTH);
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS12_PBE_keyivgen)
+LCRYPTO_ALIAS(PKCS12_PBE_keyivgen);
diff --git a/lib/libcrypto/pkcs12/p12_crt.c b/lib/libcrypto/pkcs12/p12_crt.c
index 8655be108ef..90a0cbe555d 100644
--- a/lib/libcrypto/pkcs12/p12_crt.c
+++ b/lib/libcrypto/pkcs12/p12_crt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_crt.c,v 1.22 2023/01/24 09:48:57 job Exp $ */
+/* $OpenBSD: p12_crt.c,v 1.23 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -184,7 +184,7 @@ err:
 		sk_PKCS12_SAFEBAG_pop_free(bags, PKCS12_SAFEBAG_free);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_create)
+LCRYPTO_ALIAS(PKCS12_create);
 
 PKCS12_SAFEBAG *
 PKCS12_add_cert(STACK_OF(PKCS12_SAFEBAG) **pbags, X509 *cert)
@@ -222,7 +222,7 @@ err:
 
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_add_cert)
+LCRYPTO_ALIAS(PKCS12_add_cert);
 
 PKCS12_SAFEBAG *
 PKCS12_add_key(STACK_OF(PKCS12_SAFEBAG) **pbags, EVP_PKEY *key, int key_usage,
@@ -263,7 +263,7 @@ err:
 
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_add_key)
+LCRYPTO_ALIAS(PKCS12_add_key);
 
 int
 PKCS12_add_safe(STACK_OF(PKCS7) **psafes, STACK_OF(PKCS12_SAFEBAG) *bags,
@@ -307,7 +307,7 @@ err:
 
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS12_add_safe)
+LCRYPTO_ALIAS(PKCS12_add_safe);
 
 static int
 pkcs12_add_bag(STACK_OF(PKCS12_SAFEBAG) **pbags, PKCS12_SAFEBAG *bag)
@@ -354,4 +354,4 @@ PKCS12_add_safes(STACK_OF(PKCS7) *safes, int nid_p7)
 
 	return p12;
 }
-LCRYPTO_ALIAS(PKCS12_add_safes)
+LCRYPTO_ALIAS(PKCS12_add_safes);
diff --git a/lib/libcrypto/pkcs12/p12_decr.c b/lib/libcrypto/pkcs12/p12_decr.c
index 2d3d284a53d..ea7f6a5ffa2 100644
--- a/lib/libcrypto/pkcs12/p12_decr.c
+++ b/lib/libcrypto/pkcs12/p12_decr.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_decr.c,v 1.23 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_decr.c,v 1.24 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -116,7 +116,7 @@ err:
 	return out;
 
 }
-LCRYPTO_ALIAS(PKCS12_pbe_crypt)
+LCRYPTO_ALIAS(PKCS12_pbe_crypt);
 
 /* Decrypt an OCTET STRING and decode ASN1 structure
  * if zbuf set zero buffer after use.
@@ -145,7 +145,7 @@ PKCS12_item_decrypt_d2i(const X509_ALGOR *algor, const ASN1_ITEM *it,
 	free(out);
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS12_item_decrypt_d2i)
+LCRYPTO_ALIAS(PKCS12_item_decrypt_d2i);
 
 /* Encode ASN1 structure and encrypt, return OCTET STRING
  * if zbuf set zero encoding.
@@ -184,6 +184,6 @@ err:
 	ASN1_OCTET_STRING_free(oct);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_item_i2d_encrypt)
+LCRYPTO_ALIAS(PKCS12_item_i2d_encrypt);
 
 IMPLEMENT_PKCS12_STACK_OF(PKCS7)
diff --git a/lib/libcrypto/pkcs12/p12_init.c b/lib/libcrypto/pkcs12/p12_init.c
index b865017c8d2..09ff0d5593b 100644
--- a/lib/libcrypto/pkcs12/p12_init.c
+++ b/lib/libcrypto/pkcs12/p12_init.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_init.c,v 1.15 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_init.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -98,4 +98,4 @@ err:
 		PKCS12_free(pkcs12);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS12_init)
+LCRYPTO_ALIAS(PKCS12_init);
diff --git a/lib/libcrypto/pkcs12/p12_key.c b/lib/libcrypto/pkcs12/p12_key.c
index 57cfd8b0775..8812f1c06a8 100644
--- a/lib/libcrypto/pkcs12/p12_key.c
+++ b/lib/libcrypto/pkcs12/p12_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_key.c,v 1.33 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_key.c,v 1.34 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -93,7 +93,7 @@ PKCS12_key_gen_asc(const char *pass, int passlen, unsigned char *salt,
 	freezero(unipass, uniplen);
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS12_key_gen_asc)
+LCRYPTO_ALIAS(PKCS12_key_gen_asc);
 
 int
 PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
@@ -194,4 +194,4 @@ PKCS12_key_gen_uni(unsigned char *pass, int passlen, unsigned char *salt,
 
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS12_key_gen_uni)
+LCRYPTO_ALIAS(PKCS12_key_gen_uni);
diff --git a/lib/libcrypto/pkcs12/p12_kiss.c b/lib/libcrypto/pkcs12/p12_kiss.c
index 1cf2fa7d495..48bbd137c6a 100644
--- a/lib/libcrypto/pkcs12/p12_kiss.c
+++ b/lib/libcrypto/pkcs12/p12_kiss.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_kiss.c,v 1.26 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_kiss.c,v 1.27 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -168,7 +168,7 @@ err:
 
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS12_parse)
+LCRYPTO_ALIAS(PKCS12_parse);
 
 /* Parse the outer PKCS#12 structure */
 
diff --git a/lib/libcrypto/pkcs12/p12_mutl.c b/lib/libcrypto/pkcs12/p12_mutl.c
index abfd9dd4b74..f0e6df9eb6e 100644
--- a/lib/libcrypto/pkcs12/p12_mutl.c
+++ b/lib/libcrypto/pkcs12/p12_mutl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_mutl.c,v 1.34 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_mutl.c,v 1.35 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -78,7 +78,7 @@ PKCS12_mac_present(const PKCS12 *p12)
 {
 	return p12->mac != NULL;
 }
-LCRYPTO_ALIAS(PKCS12_mac_present)
+LCRYPTO_ALIAS(PKCS12_mac_present);
 
 void
 PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, const X509_ALGOR **pmacalg,
@@ -106,7 +106,7 @@ PKCS12_get0_mac(const ASN1_OCTET_STRING **pmac, const X509_ALGOR **pmacalg,
 	if (piter != NULL)
 		*piter = p12->mac->iter;
 }
-LCRYPTO_ALIAS(PKCS12_get0_mac)
+LCRYPTO_ALIAS(PKCS12_get0_mac);
 
 /* Generate a MAC */
 int
@@ -169,7 +169,7 @@ PKCS12_gen_mac(PKCS12 *p12, const char *pass, int passlen,
 
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS12_gen_mac)
+LCRYPTO_ALIAS(PKCS12_gen_mac);
 
 /* Verify the mac */
 int
@@ -191,7 +191,7 @@ PKCS12_verify_mac(PKCS12 *p12, const char *pass, int passlen)
 		return 0;
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS12_verify_mac)
+LCRYPTO_ALIAS(PKCS12_verify_mac);
 
 /* Set a mac */
 
@@ -219,7 +219,7 @@ PKCS12_set_mac(PKCS12 *p12, const char *pass, int passlen, unsigned char *salt,
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS12_set_mac)
+LCRYPTO_ALIAS(PKCS12_set_mac);
 
 /* Set up a mac structure */
 int
@@ -259,5 +259,5 @@ PKCS12_setup_mac(PKCS12 *p12, int iter, unsigned char *salt, int saltlen,
 
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS12_setup_mac)
+LCRYPTO_ALIAS(PKCS12_setup_mac);
 #endif
diff --git a/lib/libcrypto/pkcs12/p12_npas.c b/lib/libcrypto/pkcs12/p12_npas.c
index 1e2538717e0..30dd2ef8c40 100644
--- a/lib/libcrypto/pkcs12/p12_npas.c
+++ b/lib/libcrypto/pkcs12/p12_npas.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_npas.c,v 1.17 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_npas.c,v 1.18 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -103,7 +103,7 @@ PKCS12_newpass(PKCS12 *p12, const char *oldpass, const char *newpass)
 
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS12_newpass)
+LCRYPTO_ALIAS(PKCS12_newpass);
 
 /* Parse the outer PKCS#12 structure */
 
diff --git a/lib/libcrypto/pkcs12/p12_p8d.c b/lib/libcrypto/pkcs12/p12_p8d.c
index 53942a1d702..dd5e8d9875c 100644
--- a/lib/libcrypto/pkcs12/p12_p8d.c
+++ b/lib/libcrypto/pkcs12/p12_p8d.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_p8d.c,v 1.10 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_p8d.c,v 1.11 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2001.
  */
@@ -68,4 +68,4 @@ PKCS8_decrypt(const X509_SIG *p8, const char *pass, int passlen)
 	return PKCS12_item_decrypt_d2i(p8->algor,
 	    &PKCS8_PRIV_KEY_INFO_it, pass, passlen, p8->digest, 1);
 }
-LCRYPTO_ALIAS(PKCS8_decrypt)
+LCRYPTO_ALIAS(PKCS8_decrypt);
diff --git a/lib/libcrypto/pkcs12/p12_p8e.c b/lib/libcrypto/pkcs12/p12_p8e.c
index 147d207cc87..87c4be56a31 100644
--- a/lib/libcrypto/pkcs12/p12_p8e.c
+++ b/lib/libcrypto/pkcs12/p12_p8e.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_p8e.c,v 1.11 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_p8e.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2001.
  */
@@ -100,4 +100,4 @@ err:
 	X509_SIG_free(p8);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS8_encrypt)
+LCRYPTO_ALIAS(PKCS8_encrypt);
diff --git a/lib/libcrypto/pkcs12/p12_sbag.c b/lib/libcrypto/pkcs12/p12_sbag.c
index 16ada0eeb1e..b7772b67b8a 100644
--- a/lib/libcrypto/pkcs12/p12_sbag.c
+++ b/lib/libcrypto/pkcs12/p12_sbag.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_sbag.c,v 1.7 2022/11/26 16:08:53 tb Exp $ */
+/* $OpenBSD: p12_sbag.c,v 1.8 2023/02/16 08:38:17 tb Exp $ */
 /*
  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
  * 1999-2018.
@@ -70,14 +70,14 @@ PKCS12_SAFEBAG_get0_attr(const PKCS12_SAFEBAG *bag, int attr_nid)
 {
 	return PKCS12_get_attr_gen(bag->attrib, attr_nid);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attr)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_attr);
 
 ASN1_TYPE *
 PKCS8_get_attr(PKCS8_PRIV_KEY_INFO *p8, int attr_nid)
 {
 	return PKCS12_get_attr_gen(p8->attributes, attr_nid);
 }
-LCRYPTO_ALIAS(PKCS8_get_attr)
+LCRYPTO_ALIAS(PKCS8_get_attr);
 
 const PKCS8_PRIV_KEY_INFO *
 PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag)
@@ -87,7 +87,7 @@ PKCS12_SAFEBAG_get0_p8inf(const PKCS12_SAFEBAG *bag)
 
 	return bag->value.keybag;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_p8inf)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_p8inf);
 
 const X509_SIG *
 PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag)
@@ -97,7 +97,7 @@ PKCS12_SAFEBAG_get0_pkcs8(const PKCS12_SAFEBAG *bag)
 
 	return bag->value.shkeybag;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_pkcs8)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_pkcs8);
 
 const STACK_OF(PKCS12_SAFEBAG) *
 PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag)
@@ -107,21 +107,21 @@ PKCS12_SAFEBAG_get0_safes(const PKCS12_SAFEBAG *bag)
 
 	return bag->value.safes;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_safes)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_safes);
 
 const ASN1_OBJECT *
 PKCS12_SAFEBAG_get0_type(const PKCS12_SAFEBAG *bag)
 {
 	return bag->type;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_type)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get0_type);
 
 int
 PKCS12_SAFEBAG_get_nid(const PKCS12_SAFEBAG *bag)
 {
 	return OBJ_obj2nid(bag->type);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_nid)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_nid);
 
 int
 PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag)
@@ -136,7 +136,7 @@ PKCS12_SAFEBAG_get_bag_nid(const PKCS12_SAFEBAG *bag)
 
 	return -1;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_bag_nid)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get_bag_nid);
 
 X509 *
 PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag)
@@ -147,7 +147,7 @@ PKCS12_SAFEBAG_get1_cert(const PKCS12_SAFEBAG *bag)
 		return NULL;
 	return ASN1_item_unpack(bag->value.bag->value.octet, &X509_it);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_cert)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_cert);
 
 X509_CRL *
 PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag)
@@ -158,7 +158,7 @@ PKCS12_SAFEBAG_get1_crl(const PKCS12_SAFEBAG *bag)
 		return NULL;
 	return ASN1_item_unpack(bag->value.bag->value.octet, &X509_CRL_it);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_crl)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_get1_crl);
 
 PKCS12_SAFEBAG *
 PKCS12_SAFEBAG_create_cert(X509 *x509)
@@ -166,7 +166,7 @@ PKCS12_SAFEBAG_create_cert(X509 *x509)
 	return PKCS12_item_pack_safebag(x509, &X509_it,
 	    NID_x509Certificate, NID_certBag);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_cert)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_cert);
 
 PKCS12_SAFEBAG *
 PKCS12_SAFEBAG_create_crl(X509_CRL *crl)
@@ -174,7 +174,7 @@ PKCS12_SAFEBAG_create_crl(X509_CRL *crl)
 	return PKCS12_item_pack_safebag(crl, &X509_CRL_it,
 	    NID_x509Crl, NID_crlBag);
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_crl)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_crl);
 
 /* Turn PKCS8 object into a keybag */
 
@@ -193,7 +193,7 @@ PKCS12_SAFEBAG_create0_p8inf(PKCS8_PRIV_KEY_INFO *p8)
 
 	return bag;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_p8inf)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_p8inf);
 
 /* Turn PKCS8 object into a shrouded keybag */
 
@@ -213,7 +213,7 @@ PKCS12_SAFEBAG_create0_pkcs8(X509_SIG *p8)
 
 	return bag;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_pkcs8)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create0_pkcs8);
 
 PKCS12_SAFEBAG *
 PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, const char *pass, int passlen,
@@ -237,4 +237,4 @@ PKCS12_SAFEBAG_create_pkcs8_encrypt(int pbe_nid, const char *pass, int passlen,
 
 	return bag;
 }
-LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_pkcs8_encrypt)
+LCRYPTO_ALIAS(PKCS12_SAFEBAG_create_pkcs8_encrypt);
diff --git a/lib/libcrypto/pkcs12/p12_utl.c b/lib/libcrypto/pkcs12/p12_utl.c
index 0758e875ae7..72692a9eae9 100644
--- a/lib/libcrypto/pkcs12/p12_utl.c
+++ b/lib/libcrypto/pkcs12/p12_utl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: p12_utl.c,v 1.20 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: p12_utl.c,v 1.21 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -100,7 +100,7 @@ OPENSSL_asc2uni(const char *asc, int asclen, unsigned char **uni, int *unilen)
 		*uni = unitmp;
 	return unitmp;
 }
-LCRYPTO_ALIAS(OPENSSL_asc2uni)
+LCRYPTO_ALIAS(OPENSSL_asc2uni);
 
 char *
 OPENSSL_uni2asc(const unsigned char *uni, int unilen)
@@ -126,32 +126,32 @@ OPENSSL_uni2asc(const unsigned char *uni, int unilen)
 	asctmp[asclen - 1] = '\0';
 	return asctmp;
 }
-LCRYPTO_ALIAS(OPENSSL_uni2asc)
+LCRYPTO_ALIAS(OPENSSL_uni2asc);
 
 int
 i2d_PKCS12_bio(BIO *bp, PKCS12 *p12)
 {
 	return ASN1_item_i2d_bio(&PKCS12_it, bp, p12);
 }
-LCRYPTO_ALIAS(i2d_PKCS12_bio)
+LCRYPTO_ALIAS(i2d_PKCS12_bio);
 
 int
 i2d_PKCS12_fp(FILE *fp, PKCS12 *p12)
 {
 	return ASN1_item_i2d_fp(&PKCS12_it, fp, p12);
 }
-LCRYPTO_ALIAS(i2d_PKCS12_fp)
+LCRYPTO_ALIAS(i2d_PKCS12_fp);
 
 PKCS12 *
 d2i_PKCS12_bio(BIO *bp, PKCS12 **p12)
 {
 	return ASN1_item_d2i_bio(&PKCS12_it, bp, p12);
 }
-LCRYPTO_ALIAS(d2i_PKCS12_bio)
+LCRYPTO_ALIAS(d2i_PKCS12_bio);
 
 PKCS12 *
 d2i_PKCS12_fp(FILE *fp, PKCS12 **p12)
 {
 	    return ASN1_item_d2i_fp(&PKCS12_it, fp, p12);
 }
-LCRYPTO_ALIAS(d2i_PKCS12_fp)
+LCRYPTO_ALIAS(d2i_PKCS12_fp);
diff --git a/lib/libcrypto/pkcs12/pk12err.c b/lib/libcrypto/pkcs12/pk12err.c
index 7e9149288d7..3af03528a23 100644
--- a/lib/libcrypto/pkcs12/pk12err.c
+++ b/lib/libcrypto/pkcs12/pk12err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk12err.c,v 1.13 2022/11/12 13:03:28 beck Exp $ */
+/* $OpenBSD: pk12err.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2006 The OpenSSL Project.  All rights reserved.
  *
@@ -108,4 +108,4 @@ ERR_load_PKCS12_strings(void)
 	}
 #endif
 }
-LCRYPTO_ALIAS(ERR_load_PKCS12_strings)
+LCRYPTO_ALIAS(ERR_load_PKCS12_strings);
diff --git a/lib/libcrypto/pkcs7/bio_pk7.c b/lib/libcrypto/pkcs7/bio_pk7.c
index 5f02535484d..83cf70fd877 100644
--- a/lib/libcrypto/pkcs7/bio_pk7.c
+++ b/lib/libcrypto/pkcs7/bio_pk7.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_pk7.c,v 1.6 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: bio_pk7.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -64,4 +64,4 @@ BIO_new_PKCS7(BIO *out, PKCS7 *p7)
 {
 	return BIO_new_NDEF(out, (ASN1_VALUE *)p7, &PKCS7_it);
 }
-LCRYPTO_ALIAS(BIO_new_PKCS7)
+LCRYPTO_ALIAS(BIO_new_PKCS7);
diff --git a/lib/libcrypto/pkcs7/pk7_asn1.c b/lib/libcrypto/pkcs7/pk7_asn1.c
index b0c4ee8016c..e5366ca45e8 100644
--- a/lib/libcrypto/pkcs7/pk7_asn1.c
+++ b/lib/libcrypto/pkcs7/pk7_asn1.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk7_asn1.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pk7_asn1.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2000.
  */
@@ -221,42 +221,42 @@ d2i_PKCS7(PKCS7 **a, const unsigned char **in, long len)
 	return (PKCS7 *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7)
+LCRYPTO_ALIAS(d2i_PKCS7);
 
 int
 i2d_PKCS7(PKCS7 *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7)
+LCRYPTO_ALIAS(i2d_PKCS7);
 
 PKCS7 *
 PKCS7_new(void)
 {
 	return (PKCS7 *)ASN1_item_new(&PKCS7_it);
 }
-LCRYPTO_ALIAS(PKCS7_new)
+LCRYPTO_ALIAS(PKCS7_new);
 
 void
 PKCS7_free(PKCS7 *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_it);
 }
-LCRYPTO_ALIAS(PKCS7_free)
+LCRYPTO_ALIAS(PKCS7_free);
 
 int
 i2d_PKCS7_NDEF(PKCS7 *a, unsigned char **out)
 {
 	return ASN1_item_ndef_i2d((ASN1_VALUE *)a, out, &PKCS7_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_NDEF)
+LCRYPTO_ALIAS(i2d_PKCS7_NDEF);
 
 PKCS7 *
 PKCS7_dup(PKCS7 *x)
 {
 	return ASN1_item_dup(&PKCS7_it, x);
 }
-LCRYPTO_ALIAS(PKCS7_dup)
+LCRYPTO_ALIAS(PKCS7_dup);
 
 static const ASN1_TEMPLATE PKCS7_SIGNED_seq_tt[] = {
 	{
@@ -320,28 +320,28 @@ d2i_PKCS7_SIGNED(PKCS7_SIGNED **a, const unsigned char **in, long len)
 	return (PKCS7_SIGNED *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_SIGNED_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_SIGNED)
+LCRYPTO_ALIAS(d2i_PKCS7_SIGNED);
 
 int
 i2d_PKCS7_SIGNED(PKCS7_SIGNED *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNED_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_SIGNED)
+LCRYPTO_ALIAS(i2d_PKCS7_SIGNED);
 
 PKCS7_SIGNED *
 PKCS7_SIGNED_new(void)
 {
 	return (PKCS7_SIGNED *)ASN1_item_new(&PKCS7_SIGNED_it);
 }
-LCRYPTO_ALIAS(PKCS7_SIGNED_new)
+LCRYPTO_ALIAS(PKCS7_SIGNED_new);
 
 void
 PKCS7_SIGNED_free(PKCS7_SIGNED *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNED_it);
 }
-LCRYPTO_ALIAS(PKCS7_SIGNED_free)
+LCRYPTO_ALIAS(PKCS7_SIGNED_free);
 
 /* Minor tweak to operation: free up EVP_PKEY */
 static int
@@ -436,28 +436,28 @@ d2i_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO **a, const unsigned char **in, long len)
 	return (PKCS7_SIGNER_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_SIGNER_INFO_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO)
+LCRYPTO_ALIAS(d2i_PKCS7_SIGNER_INFO);
 
 int
 i2d_PKCS7_SIGNER_INFO(PKCS7_SIGNER_INFO *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGNER_INFO_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO)
+LCRYPTO_ALIAS(i2d_PKCS7_SIGNER_INFO);
 
 PKCS7_SIGNER_INFO *
 PKCS7_SIGNER_INFO_new(void)
 {
 	return (PKCS7_SIGNER_INFO *)ASN1_item_new(&PKCS7_SIGNER_INFO_it);
 }
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_new);
 
 void
 PKCS7_SIGNER_INFO_free(PKCS7_SIGNER_INFO *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGNER_INFO_it);
 }
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_free);
 
 static const ASN1_TEMPLATE PKCS7_ISSUER_AND_SERIAL_seq_tt[] = {
 	{
@@ -493,28 +493,28 @@ d2i_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL **a, const unsigned char **i
 	return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_ISSUER_AND_SERIAL_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL)
+LCRYPTO_ALIAS(d2i_PKCS7_ISSUER_AND_SERIAL);
 
 int
 i2d_PKCS7_ISSUER_AND_SERIAL(PKCS7_ISSUER_AND_SERIAL *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ISSUER_AND_SERIAL_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL)
+LCRYPTO_ALIAS(i2d_PKCS7_ISSUER_AND_SERIAL);
 
 PKCS7_ISSUER_AND_SERIAL *
 PKCS7_ISSUER_AND_SERIAL_new(void)
 {
 	return (PKCS7_ISSUER_AND_SERIAL *)ASN1_item_new(&PKCS7_ISSUER_AND_SERIAL_it);
 }
-LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new)
+LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_new);
 
 void
 PKCS7_ISSUER_AND_SERIAL_free(PKCS7_ISSUER_AND_SERIAL *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ISSUER_AND_SERIAL_it);
 }
-LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free)
+LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_free);
 
 static const ASN1_TEMPLATE PKCS7_ENVELOPE_seq_tt[] = {
 	{
@@ -557,28 +557,28 @@ d2i_PKCS7_ENVELOPE(PKCS7_ENVELOPE **a, const unsigned char **in, long len)
 	return (PKCS7_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE)
+LCRYPTO_ALIAS(d2i_PKCS7_ENVELOPE);
 
 int
 i2d_PKCS7_ENVELOPE(PKCS7_ENVELOPE *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE)
+LCRYPTO_ALIAS(i2d_PKCS7_ENVELOPE);
 
 PKCS7_ENVELOPE *
 PKCS7_ENVELOPE_new(void)
 {
 	return (PKCS7_ENVELOPE *)ASN1_item_new(&PKCS7_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(PKCS7_ENVELOPE_new)
+LCRYPTO_ALIAS(PKCS7_ENVELOPE_new);
 
 void
 PKCS7_ENVELOPE_free(PKCS7_ENVELOPE *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(PKCS7_ENVELOPE_free)
+LCRYPTO_ALIAS(PKCS7_ENVELOPE_free);
 
 /* Minor tweak to operation: free up X509 */
 static int
@@ -647,28 +647,28 @@ d2i_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO **a, const unsigned char **in, long len)
 	return (PKCS7_RECIP_INFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_RECIP_INFO_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO)
+LCRYPTO_ALIAS(d2i_PKCS7_RECIP_INFO);
 
 int
 i2d_PKCS7_RECIP_INFO(PKCS7_RECIP_INFO *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_RECIP_INFO_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO)
+LCRYPTO_ALIAS(i2d_PKCS7_RECIP_INFO);
 
 PKCS7_RECIP_INFO *
 PKCS7_RECIP_INFO_new(void)
 {
 	return (PKCS7_RECIP_INFO *)ASN1_item_new(&PKCS7_RECIP_INFO_it);
 }
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_new);
 
 void
 PKCS7_RECIP_INFO_free(PKCS7_RECIP_INFO *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_RECIP_INFO_it);
 }
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_free);
 
 static const ASN1_TEMPLATE PKCS7_ENC_CONTENT_seq_tt[] = {
 	{
@@ -711,28 +711,28 @@ d2i_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT **a, const unsigned char **in, long len)
 	return (PKCS7_ENC_CONTENT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_ENC_CONTENT_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT)
+LCRYPTO_ALIAS(d2i_PKCS7_ENC_CONTENT);
 
 int
 i2d_PKCS7_ENC_CONTENT(PKCS7_ENC_CONTENT *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENC_CONTENT_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT)
+LCRYPTO_ALIAS(i2d_PKCS7_ENC_CONTENT);
 
 PKCS7_ENC_CONTENT *
 PKCS7_ENC_CONTENT_new(void)
 {
 	return (PKCS7_ENC_CONTENT *)ASN1_item_new(&PKCS7_ENC_CONTENT_it);
 }
-LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new)
+LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_new);
 
 void
 PKCS7_ENC_CONTENT_free(PKCS7_ENC_CONTENT *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENC_CONTENT_it);
 }
-LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free)
+LCRYPTO_ALIAS(PKCS7_ENC_CONTENT_free);
 
 static const ASN1_TEMPLATE PKCS7_SIGN_ENVELOPE_seq_tt[] = {
 	{
@@ -803,28 +803,28 @@ d2i_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE **a, const unsigned char **in, long
 	return (PKCS7_SIGN_ENVELOPE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_SIGN_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE)
+LCRYPTO_ALIAS(d2i_PKCS7_SIGN_ENVELOPE);
 
 int
 i2d_PKCS7_SIGN_ENVELOPE(PKCS7_SIGN_ENVELOPE *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_SIGN_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE)
+LCRYPTO_ALIAS(i2d_PKCS7_SIGN_ENVELOPE);
 
 PKCS7_SIGN_ENVELOPE *
 PKCS7_SIGN_ENVELOPE_new(void)
 {
 	return (PKCS7_SIGN_ENVELOPE *)ASN1_item_new(&PKCS7_SIGN_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new)
+LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_new);
 
 void
 PKCS7_SIGN_ENVELOPE_free(PKCS7_SIGN_ENVELOPE *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_SIGN_ENVELOPE_it);
 }
-LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free)
+LCRYPTO_ALIAS(PKCS7_SIGN_ENVELOPE_free);
 
 static const ASN1_TEMPLATE PKCS7_ENCRYPT_seq_tt[] = {
 	{
@@ -860,28 +860,28 @@ d2i_PKCS7_ENCRYPT(PKCS7_ENCRYPT **a, const unsigned char **in, long len)
 	return (PKCS7_ENCRYPT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_ENCRYPT_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT)
+LCRYPTO_ALIAS(d2i_PKCS7_ENCRYPT);
 
 int
 i2d_PKCS7_ENCRYPT(PKCS7_ENCRYPT *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_ENCRYPT_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT)
+LCRYPTO_ALIAS(i2d_PKCS7_ENCRYPT);
 
 PKCS7_ENCRYPT *
 PKCS7_ENCRYPT_new(void)
 {
 	return (PKCS7_ENCRYPT *)ASN1_item_new(&PKCS7_ENCRYPT_it);
 }
-LCRYPTO_ALIAS(PKCS7_ENCRYPT_new)
+LCRYPTO_ALIAS(PKCS7_ENCRYPT_new);
 
 void
 PKCS7_ENCRYPT_free(PKCS7_ENCRYPT *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_ENCRYPT_it);
 }
-LCRYPTO_ALIAS(PKCS7_ENCRYPT_free)
+LCRYPTO_ALIAS(PKCS7_ENCRYPT_free);
 
 static const ASN1_TEMPLATE PKCS7_DIGEST_seq_tt[] = {
 	{
@@ -931,28 +931,28 @@ d2i_PKCS7_DIGEST(PKCS7_DIGEST **a, const unsigned char **in, long len)
 	return (PKCS7_DIGEST *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKCS7_DIGEST_it);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_DIGEST)
+LCRYPTO_ALIAS(d2i_PKCS7_DIGEST);
 
 int
 i2d_PKCS7_DIGEST(PKCS7_DIGEST *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKCS7_DIGEST_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_DIGEST)
+LCRYPTO_ALIAS(i2d_PKCS7_DIGEST);
 
 PKCS7_DIGEST *
 PKCS7_DIGEST_new(void)
 {
 	return (PKCS7_DIGEST *)ASN1_item_new(&PKCS7_DIGEST_it);
 }
-LCRYPTO_ALIAS(PKCS7_DIGEST_new)
+LCRYPTO_ALIAS(PKCS7_DIGEST_new);
 
 void
 PKCS7_DIGEST_free(PKCS7_DIGEST *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKCS7_DIGEST_it);
 }
-LCRYPTO_ALIAS(PKCS7_DIGEST_free)
+LCRYPTO_ALIAS(PKCS7_DIGEST_free);
 
 /* Specials for authenticated attributes */
 
@@ -1007,35 +1007,35 @@ PKCS7_print_ctx(BIO *out, PKCS7 *x, int indent, const ASN1_PCTX *pctx)
 	return ASN1_item_print(out, (ASN1_VALUE *)x, indent,
 	    &PKCS7_it, pctx);
 }
-LCRYPTO_ALIAS(PKCS7_print_ctx)
+LCRYPTO_ALIAS(PKCS7_print_ctx);
 
 PKCS7 *
 d2i_PKCS7_bio(BIO *bp, PKCS7 **p7)
 {
 	return ASN1_item_d2i_bio(&PKCS7_it, bp, p7);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_bio)
+LCRYPTO_ALIAS(d2i_PKCS7_bio);
 
 int
 i2d_PKCS7_bio(BIO *bp, PKCS7 *p7)
 {
 	return ASN1_item_i2d_bio(&PKCS7_it, bp, p7);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_bio)
+LCRYPTO_ALIAS(i2d_PKCS7_bio);
 
 PKCS7 *
 d2i_PKCS7_fp(FILE *fp, PKCS7 **p7)
 {
 	return ASN1_item_d2i_fp(&PKCS7_it, fp, p7);
 }
-LCRYPTO_ALIAS(d2i_PKCS7_fp)
+LCRYPTO_ALIAS(d2i_PKCS7_fp);
 
 int
 i2d_PKCS7_fp(FILE *fp, PKCS7 *p7)
 {
 	return ASN1_item_i2d_fp(&PKCS7_it, fp, p7);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_fp)
+LCRYPTO_ALIAS(i2d_PKCS7_fp);
 
 int
 PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
@@ -1044,4 +1044,4 @@ PKCS7_ISSUER_AND_SERIAL_digest(PKCS7_ISSUER_AND_SERIAL *data,
 	return(ASN1_item_digest(&PKCS7_ISSUER_AND_SERIAL_it, type,
 	    (char *)data, md, len));
 }
-LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest)
+LCRYPTO_ALIAS(PKCS7_ISSUER_AND_SERIAL_digest);
diff --git a/lib/libcrypto/pkcs7/pk7_attr.c b/lib/libcrypto/pkcs7/pk7_attr.c
index 1a5dc06dc57..5eff5241ef7 100644
--- a/lib/libcrypto/pkcs7/pk7_attr.c
+++ b/lib/libcrypto/pkcs7/pk7_attr.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk7_attr.c,v 1.13 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pk7_attr.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2001.
  */
@@ -79,7 +79,7 @@ PKCS7_add_attrib_smimecap(PKCS7_SIGNER_INFO *si, STACK_OF(X509_ALGOR) *cap)
 	return PKCS7_add_signed_attribute(si, NID_SMIMECapabilities,
 	    V_ASN1_SEQUENCE, seq);
 }
-LCRYPTO_ALIAS(PKCS7_add_attrib_smimecap)
+LCRYPTO_ALIAS(PKCS7_add_attrib_smimecap);
 
 STACK_OF(X509_ALGOR) *
 PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si)
@@ -95,7 +95,7 @@ PKCS7_get_smimecap(PKCS7_SIGNER_INFO *si)
 	ASN1_item_d2i(NULL, &p, cap->value.sequence->length,
 	    &X509_ALGORS_it);
 }
-LCRYPTO_ALIAS(PKCS7_get_smimecap)
+LCRYPTO_ALIAS(PKCS7_get_smimecap);
 
 /* Basic smime-capabilities OID and optional integer arg */
 int
@@ -132,7 +132,7 @@ err:
 	X509_ALGOR_free(alg);
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS7_simple_smimecap)
+LCRYPTO_ALIAS(PKCS7_simple_smimecap);
 
 int
 PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid)
@@ -144,7 +144,7 @@ PKCS7_add_attrib_content_type(PKCS7_SIGNER_INFO *si, ASN1_OBJECT *coid)
 	return PKCS7_add_signed_attribute(si, NID_pkcs9_contentType,
 	    V_ASN1_OBJECT, coid);
 }
-LCRYPTO_ALIAS(PKCS7_add_attrib_content_type)
+LCRYPTO_ALIAS(PKCS7_add_attrib_content_type);
 
 int
 PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t)
@@ -156,7 +156,7 @@ PKCS7_add0_attrib_signing_time(PKCS7_SIGNER_INFO *si, ASN1_TIME *t)
 	return PKCS7_add_signed_attribute(si, NID_pkcs9_signingTime,
 	    V_ASN1_UTCTIME, t);
 }
-LCRYPTO_ALIAS(PKCS7_add0_attrib_signing_time)
+LCRYPTO_ALIAS(PKCS7_add0_attrib_signing_time);
 
 int
 PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, const unsigned char *md,
@@ -175,4 +175,4 @@ PKCS7_add1_attrib_digest(PKCS7_SIGNER_INFO *si, const unsigned char *md,
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS7_add1_attrib_digest)
+LCRYPTO_ALIAS(PKCS7_add1_attrib_digest);
diff --git a/lib/libcrypto/pkcs7/pk7_doit.c b/lib/libcrypto/pkcs7/pk7_doit.c
index 3e2d4c2119e..1fcc37a983f 100644
--- a/lib/libcrypto/pkcs7/pk7_doit.c
+++ b/lib/libcrypto/pkcs7/pk7_doit.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk7_doit.c,v 1.50 2022/12/26 07:18:52 jmc Exp $ */
+/* $OpenBSD: pk7_doit.c,v 1.51 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -404,7 +404,7 @@ err:
 	}
 	return (out);
 }
-LCRYPTO_ALIAS(PKCS7_dataInit)
+LCRYPTO_ALIAS(PKCS7_dataInit);
 
 static int
 pkcs7_cmp_ri(PKCS7_RECIP_INFO *ri, X509 *pcert)
@@ -630,7 +630,7 @@ err:
 	}
 	return (out);
 }
-LCRYPTO_ALIAS(PKCS7_dataDecode)
+LCRYPTO_ALIAS(PKCS7_dataDecode);
 
 static BIO *
 PKCS7_find_digest(EVP_MD_CTX **pmd, BIO *bio, int nid)
@@ -859,7 +859,7 @@ err:
 	EVP_MD_CTX_cleanup(&ctx_tmp);
 	return (ret);
 }
-LCRYPTO_ALIAS(PKCS7_dataFinal)
+LCRYPTO_ALIAS(PKCS7_dataFinal);
 
 int
 PKCS7_SIGNER_INFO_sign(PKCS7_SIGNER_INFO *si)
@@ -918,7 +918,7 @@ err:
 	EVP_MD_CTX_cleanup(&mctx);
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_sign)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_sign);
 
 int
 PKCS7_dataVerify(X509_STORE *cert_store, X509_STORE_CTX *ctx, BIO *bio,
@@ -980,7 +980,7 @@ err:
 	
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS7_dataVerify)
+LCRYPTO_ALIAS(PKCS7_dataVerify);
 
 int
 PKCS7_signatureVerify(BIO *bio, PKCS7 *p7, PKCS7_SIGNER_INFO *si, X509 *x509)
@@ -1087,7 +1087,7 @@ err:
 	EVP_MD_CTX_cleanup(&mdc_tmp);
 	return (ret);
 }
-LCRYPTO_ALIAS(PKCS7_signatureVerify)
+LCRYPTO_ALIAS(PKCS7_signatureVerify);
 
 PKCS7_ISSUER_AND_SERIAL *
 PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx)
@@ -1110,21 +1110,21 @@ PKCS7_get_issuer_and_serial(PKCS7 *p7, int idx)
 	ri = sk_PKCS7_RECIP_INFO_value(rsk, idx);
 	return (ri->issuer_and_serial);
 }
-LCRYPTO_ALIAS(PKCS7_get_issuer_and_serial)
+LCRYPTO_ALIAS(PKCS7_get_issuer_and_serial);
 
 ASN1_TYPE *
 PKCS7_get_signed_attribute(PKCS7_SIGNER_INFO *si, int nid)
 {
 	return (get_attribute(si->auth_attr, nid));
 }
-LCRYPTO_ALIAS(PKCS7_get_signed_attribute)
+LCRYPTO_ALIAS(PKCS7_get_signed_attribute);
 
 ASN1_TYPE *
 PKCS7_get_attribute(PKCS7_SIGNER_INFO *si, int nid)
 {
 	return (get_attribute(si->unauth_attr, nid));
 }
-LCRYPTO_ALIAS(PKCS7_get_attribute)
+LCRYPTO_ALIAS(PKCS7_get_attribute);
 
 static ASN1_TYPE *
 get_attribute(STACK_OF(X509_ATTRIBUTE) *sk, int nid)
@@ -1155,7 +1155,7 @@ PKCS7_digest_from_attributes(STACK_OF(X509_ATTRIBUTE) *sk)
 		return NULL;
 	return astype->value.octet_string;
 }
-LCRYPTO_ALIAS(PKCS7_digest_from_attributes)
+LCRYPTO_ALIAS(PKCS7_digest_from_attributes);
 
 int
 PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
@@ -1177,7 +1177,7 @@ PKCS7_set_signed_attributes(PKCS7_SIGNER_INFO *p7si,
 	}
 	return (1);
 }
-LCRYPTO_ALIAS(PKCS7_set_signed_attributes)
+LCRYPTO_ALIAS(PKCS7_set_signed_attributes);
 
 int
 PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK_OF(X509_ATTRIBUTE) *sk)
@@ -1198,7 +1198,7 @@ PKCS7_set_attributes(PKCS7_SIGNER_INFO *p7si, STACK_OF(X509_ATTRIBUTE) *sk)
 	}
 	return (1);
 }
-LCRYPTO_ALIAS(PKCS7_set_attributes)
+LCRYPTO_ALIAS(PKCS7_set_attributes);
 
 int
 PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
@@ -1206,14 +1206,14 @@ PKCS7_add_signed_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype,
 {
 	return (add_attribute(&(p7si->auth_attr), nid, atrtype, value));
 }
-LCRYPTO_ALIAS(PKCS7_add_signed_attribute)
+LCRYPTO_ALIAS(PKCS7_add_signed_attribute);
 
 int
 PKCS7_add_attribute(PKCS7_SIGNER_INFO *p7si, int nid, int atrtype, void *value)
 {
 	return (add_attribute(&(p7si->unauth_attr), nid, atrtype, value));
 }
-LCRYPTO_ALIAS(PKCS7_add_attribute)
+LCRYPTO_ALIAS(PKCS7_add_attribute);
 
 static int
 add_attribute(STACK_OF(X509_ATTRIBUTE) **sk, int nid, int atrtype, void *value)
diff --git a/lib/libcrypto/pkcs7/pk7_lib.c b/lib/libcrypto/pkcs7/pk7_lib.c
index efb6343f546..6eda698c94a 100644
--- a/lib/libcrypto/pkcs7/pk7_lib.c
+++ b/lib/libcrypto/pkcs7/pk7_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk7_lib.c,v 1.25 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: pk7_lib.c,v 1.26 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -109,7 +109,7 @@ PKCS7_ctrl(PKCS7 *p7, int cmd, long larg, char *parg)
 	}
 	return (ret);
 }
-LCRYPTO_ALIAS(PKCS7_ctrl)
+LCRYPTO_ALIAS(PKCS7_ctrl);
 
 int
 PKCS7_content_new(PKCS7 *p7, int type)
@@ -129,7 +129,7 @@ err:
 		PKCS7_free(ret);
 	return (0);
 }
-LCRYPTO_ALIAS(PKCS7_content_new)
+LCRYPTO_ALIAS(PKCS7_content_new);
 
 int
 PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
@@ -160,7 +160,7 @@ PKCS7_set_content(PKCS7 *p7, PKCS7 *p7_data)
 err:
 	return (0);
 }
-LCRYPTO_ALIAS(PKCS7_set_content)
+LCRYPTO_ALIAS(PKCS7_set_content);
 
 int
 PKCS7_set_type(PKCS7 *p7, int type)
@@ -230,7 +230,7 @@ PKCS7_set_type(PKCS7 *p7, int type)
 err:
 	return (0);
 }
-LCRYPTO_ALIAS(PKCS7_set_type)
+LCRYPTO_ALIAS(PKCS7_set_type);
 
 int
 PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other)
@@ -239,7 +239,7 @@ PKCS7_set0_type_other(PKCS7 *p7, int type, ASN1_TYPE *other)
 	p7->d.other = other;
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS7_set0_type_other)
+LCRYPTO_ALIAS(PKCS7_set0_type_other);
 
 int
 PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
@@ -295,7 +295,7 @@ PKCS7_add_signer(PKCS7 *p7, PKCS7_SIGNER_INFO *psi)
 		return 0;
 	return (1);
 }
-LCRYPTO_ALIAS(PKCS7_add_signer)
+LCRYPTO_ALIAS(PKCS7_add_signer);
 
 int
 PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
@@ -329,7 +329,7 @@ PKCS7_add_certificate(PKCS7 *p7, X509 *x509)
 	}
 	return (1);
 }
-LCRYPTO_ALIAS(PKCS7_add_certificate)
+LCRYPTO_ALIAS(PKCS7_add_certificate);
 
 int
 PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
@@ -364,7 +364,7 @@ PKCS7_add_crl(PKCS7 *p7, X509_CRL *crl)
 	}
 	return (1);
 }
-LCRYPTO_ALIAS(PKCS7_add_crl)
+LCRYPTO_ALIAS(PKCS7_add_crl);
 
 int
 PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
@@ -409,7 +409,7 @@ PKCS7_SIGNER_INFO_set(PKCS7_SIGNER_INFO *p7i, X509 *x509, EVP_PKEY *pkey,
 err:
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_set)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_set);
 
 PKCS7_SIGNER_INFO *
 PKCS7_add_signature(PKCS7 *p7, X509 *x509, EVP_PKEY *pkey, const EVP_MD *dgst)
@@ -439,7 +439,7 @@ err:
 		PKCS7_SIGNER_INFO_free(si);
 	return (NULL);
 }
-LCRYPTO_ALIAS(PKCS7_add_signature)
+LCRYPTO_ALIAS(PKCS7_add_signature);
 
 int
 PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md)
@@ -457,7 +457,7 @@ PKCS7_set_digest(PKCS7 *p7, const EVP_MD *md)
 	PKCS7error(PKCS7_R_WRONG_CONTENT_TYPE);
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS7_set_digest)
+LCRYPTO_ALIAS(PKCS7_set_digest);
 
 STACK_OF(PKCS7_SIGNER_INFO) *
 PKCS7_get_signer_info(PKCS7 *p7)
@@ -471,7 +471,7 @@ PKCS7_get_signer_info(PKCS7 *p7)
 	} else
 		return (NULL);
 }
-LCRYPTO_ALIAS(PKCS7_get_signer_info)
+LCRYPTO_ALIAS(PKCS7_get_signer_info);
 
 void
 PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
@@ -484,7 +484,7 @@ PKCS7_SIGNER_INFO_get0_algs(PKCS7_SIGNER_INFO *si, EVP_PKEY **pk,
 	if (psig)
 		*psig = si->digest_enc_alg;
 }
-LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_get0_algs)
+LCRYPTO_ALIAS(PKCS7_SIGNER_INFO_get0_algs);
 
 void
 PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc)
@@ -492,7 +492,7 @@ PKCS7_RECIP_INFO_get0_alg(PKCS7_RECIP_INFO *ri, X509_ALGOR **penc)
 	if (penc)
 		*penc = ri->key_enc_algor;
 }
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_get0_alg)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_get0_alg);
 
 PKCS7_RECIP_INFO *
 PKCS7_add_recipient(PKCS7 *p7, X509 *x509)
@@ -511,7 +511,7 @@ err:
 		PKCS7_RECIP_INFO_free(ri);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS7_add_recipient)
+LCRYPTO_ALIAS(PKCS7_add_recipient);
 
 int
 PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
@@ -536,7 +536,7 @@ PKCS7_add_recipient_info(PKCS7 *p7, PKCS7_RECIP_INFO *ri)
 		return 0;
 	return (1);
 }
-LCRYPTO_ALIAS(PKCS7_add_recipient_info)
+LCRYPTO_ALIAS(PKCS7_add_recipient_info);
 
 int
 PKCS7_RECIP_INFO_set(PKCS7_RECIP_INFO *p7i, X509 *x509)
@@ -583,7 +583,7 @@ err:
 	EVP_PKEY_free(pkey);
 	return 0;
 }
-LCRYPTO_ALIAS(PKCS7_RECIP_INFO_set)
+LCRYPTO_ALIAS(PKCS7_RECIP_INFO_set);
 
 X509 *
 PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
@@ -595,7 +595,7 @@ PKCS7_cert_from_signer_info(PKCS7 *p7, PKCS7_SIGNER_INFO *si)
 	else
 		return (NULL);
 }
-LCRYPTO_ALIAS(PKCS7_cert_from_signer_info)
+LCRYPTO_ALIAS(PKCS7_cert_from_signer_info);
 
 int
 PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher)
@@ -626,7 +626,7 @@ PKCS7_set_cipher(PKCS7 *p7, const EVP_CIPHER *cipher)
 	ec->cipher = cipher;
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS7_set_cipher)
+LCRYPTO_ALIAS(PKCS7_set_cipher);
 
 int
 PKCS7_stream(unsigned char ***boundary, PKCS7 *p7)
@@ -671,4 +671,4 @@ PKCS7_stream(unsigned char ***boundary, PKCS7 *p7)
 
 	return 1;
 }
-LCRYPTO_ALIAS(PKCS7_stream)
+LCRYPTO_ALIAS(PKCS7_stream);
diff --git a/lib/libcrypto/pkcs7/pk7_mime.c b/lib/libcrypto/pkcs7/pk7_mime.c
index bf7d94584b3..d5bc031e694 100644
--- a/lib/libcrypto/pkcs7/pk7_mime.c
+++ b/lib/libcrypto/pkcs7/pk7_mime.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk7_mime.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pk7_mime.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -66,7 +66,7 @@ i2d_PKCS7_bio_stream(BIO *out, PKCS7 *p7, BIO *in, int flags)
 	return i2d_ASN1_bio_stream(out, (ASN1_VALUE *)p7, in, flags,
 	    &PKCS7_it);
 }
-LCRYPTO_ALIAS(i2d_PKCS7_bio_stream)
+LCRYPTO_ALIAS(i2d_PKCS7_bio_stream);
 
 int
 PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags)
@@ -74,7 +74,7 @@ PEM_write_bio_PKCS7_stream(BIO *out, PKCS7 *p7, BIO *in, int flags)
 	return PEM_write_bio_ASN1_stream(out, (ASN1_VALUE *) p7, in, flags,
 	    "PKCS7", &PKCS7_it);
 }
-LCRYPTO_ALIAS(PEM_write_bio_PKCS7_stream)
+LCRYPTO_ALIAS(PEM_write_bio_PKCS7_stream);
 
 int
 SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags)
@@ -92,11 +92,11 @@ SMIME_write_PKCS7(BIO *bio, PKCS7 *p7, BIO *data, int flags)
 	return SMIME_write_ASN1(bio, (ASN1_VALUE *)p7, data, flags,
 	    ctype_nid, NID_undef, mdalgs, &PKCS7_it);
 }
-LCRYPTO_ALIAS(SMIME_write_PKCS7)
+LCRYPTO_ALIAS(SMIME_write_PKCS7);
 
 PKCS7 *
 SMIME_read_PKCS7(BIO *bio, BIO **bcont)
 {
 	return (PKCS7 *)SMIME_read_ASN1(bio, bcont, &PKCS7_it);
 }
-LCRYPTO_ALIAS(SMIME_read_PKCS7)
+LCRYPTO_ALIAS(SMIME_read_PKCS7);
diff --git a/lib/libcrypto/pkcs7/pk7_smime.c b/lib/libcrypto/pkcs7/pk7_smime.c
index 4324cf384bf..c113ac39540 100644
--- a/lib/libcrypto/pkcs7/pk7_smime.c
+++ b/lib/libcrypto/pkcs7/pk7_smime.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pk7_smime.c,v 1.25 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: pk7_smime.c,v 1.26 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -111,7 +111,7 @@ err:
 	PKCS7_free(p7);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS7_sign)
+LCRYPTO_ALIAS(PKCS7_sign);
 
 int
 PKCS7_final(PKCS7 *p7, BIO *data, int flags)
@@ -140,7 +140,7 @@ err:
 
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS7_final)
+LCRYPTO_ALIAS(PKCS7_final);
 
 /* Check to see if a cipher exists and if so add S/MIME capabilities */
 
@@ -223,7 +223,7 @@ err:
 		sk_X509_ALGOR_pop_free(smcap, X509_ALGOR_free);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS7_sign_add_signer)
+LCRYPTO_ALIAS(PKCS7_sign_add_signer);
 
 /* Search for a digest matching SignerInfo digest type and if found
  * copy across.
@@ -426,7 +426,7 @@ err:
 
 	return ret;
 }
-LCRYPTO_ALIAS(PKCS7_verify)
+LCRYPTO_ALIAS(PKCS7_verify);
 
 STACK_OF(X509) *
 PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags)
@@ -485,7 +485,7 @@ PKCS7_get0_signers(PKCS7 *p7, STACK_OF(X509) *certs, int flags)
 	}
 	return signers;
 }
-LCRYPTO_ALIAS(PKCS7_get0_signers)
+LCRYPTO_ALIAS(PKCS7_get0_signers);
 
 /* Build a complete PKCS#7 enveloped data */
 
@@ -529,7 +529,7 @@ err:
 	PKCS7_free(p7);
 	return NULL;
 }
-LCRYPTO_ALIAS(PKCS7_encrypt)
+LCRYPTO_ALIAS(PKCS7_encrypt);
 
 int
 PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags)
@@ -596,4 +596,4 @@ PKCS7_decrypt(PKCS7 *p7, EVP_PKEY *pkey, X509 *cert, BIO *data, int flags)
 		return ret;
 	}
 }
-LCRYPTO_ALIAS(PKCS7_decrypt)
+LCRYPTO_ALIAS(PKCS7_decrypt);
diff --git a/lib/libcrypto/pkcs7/pkcs7err.c b/lib/libcrypto/pkcs7/pkcs7err.c
index d2eab2d7f6e..d3ca0ec6dfa 100644
--- a/lib/libcrypto/pkcs7/pkcs7err.c
+++ b/lib/libcrypto/pkcs7/pkcs7err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pkcs7err.c,v 1.14 2022/11/12 12:11:14 beck Exp $ */
+/* $OpenBSD: pkcs7err.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2007 The OpenSSL Project.  All rights reserved.
  *
@@ -140,4 +140,4 @@ ERR_load_PKCS7_strings(void)
 	}
 #endif
 }
-LCRYPTO_ALIAS(ERR_load_PKCS7_strings)
+LCRYPTO_ALIAS(ERR_load_PKCS7_strings);
diff --git a/lib/libcrypto/stack/stack.c b/lib/libcrypto/stack/stack.c
index c99941aa46f..bc5b2f6e837 100644
--- a/lib/libcrypto/stack/stack.c
+++ b/lib/libcrypto/stack/stack.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: stack.c,v 1.21 2022/11/11 19:18:55 beck Exp $ */
+/* $OpenBSD: stack.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -79,7 +79,7 @@ int
 
 	return old;
 }
-LCRYPTO_ALIAS(sk_set_cmp_func)
+LCRYPTO_ALIAS(sk_set_cmp_func);
 
 _STACK *
 sk_dup(_STACK *sk)
@@ -106,14 +106,14 @@ err:
 		sk_free(ret);
 	return (NULL);
 }
-LCRYPTO_ALIAS(sk_dup)
+LCRYPTO_ALIAS(sk_dup);
 
 _STACK *
 sk_new_null(void)
 {
 	return sk_new((int (*)(const void *, const void *))0);
 }
-LCRYPTO_ALIAS(sk_new_null)
+LCRYPTO_ALIAS(sk_new_null);
 
 _STACK *
 sk_new(int (*c)(const void *, const void *))
@@ -137,7 +137,7 @@ err:
 	free(ret);
 	return (NULL);
 }
-LCRYPTO_ALIAS(sk_new)
+LCRYPTO_ALIAS(sk_new);
 
 int
 sk_insert(_STACK *st, void *data, int loc)
@@ -164,7 +164,7 @@ sk_insert(_STACK *st, void *data, int loc)
 	st->sorted = 0;
 	return (st->num);
 }
-LCRYPTO_ALIAS(sk_insert)
+LCRYPTO_ALIAS(sk_insert);
 
 void *
 sk_delete_ptr(_STACK *st, void *p)
@@ -176,7 +176,7 @@ sk_delete_ptr(_STACK *st, void *p)
 			return (sk_delete(st, i));
 	return (NULL);
 }
-LCRYPTO_ALIAS(sk_delete_ptr)
+LCRYPTO_ALIAS(sk_delete_ptr);
 
 void *
 sk_delete(_STACK *st, int loc)
@@ -194,7 +194,7 @@ sk_delete(_STACK *st, int loc)
 	st->num--;
 	return (ret);
 }
-LCRYPTO_ALIAS(sk_delete)
+LCRYPTO_ALIAS(sk_delete);
 
 static int
 internal_find(_STACK *st, void *data, int ret_val_options)
@@ -226,28 +226,28 @@ sk_find(_STACK *st, void *data)
 {
 	return internal_find(st, data, OBJ_BSEARCH_FIRST_VALUE_ON_MATCH);
 }
-LCRYPTO_ALIAS(sk_find)
+LCRYPTO_ALIAS(sk_find);
 
 int
 sk_find_ex(_STACK *st, void *data)
 {
 	return internal_find(st, data, OBJ_BSEARCH_VALUE_ON_NOMATCH);
 }
-LCRYPTO_ALIAS(sk_find_ex)
+LCRYPTO_ALIAS(sk_find_ex);
 
 int
 sk_push(_STACK *st, void *data)
 {
 	return (sk_insert(st, data, st->num));
 }
-LCRYPTO_ALIAS(sk_push)
+LCRYPTO_ALIAS(sk_push);
 
 int
 sk_unshift(_STACK *st, void *data)
 {
 	return (sk_insert(st, data, 0));
 }
-LCRYPTO_ALIAS(sk_unshift)
+LCRYPTO_ALIAS(sk_unshift);
 
 void *
 sk_shift(_STACK *st)
@@ -258,7 +258,7 @@ sk_shift(_STACK *st)
 		return (NULL);
 	return (sk_delete(st, 0));
 }
-LCRYPTO_ALIAS(sk_shift)
+LCRYPTO_ALIAS(sk_shift);
 
 void *
 sk_pop(_STACK *st)
@@ -269,7 +269,7 @@ sk_pop(_STACK *st)
 		return (NULL);
 	return (sk_delete(st, st->num - 1));
 }
-LCRYPTO_ALIAS(sk_pop)
+LCRYPTO_ALIAS(sk_pop);
 
 void
 sk_zero(_STACK *st)
@@ -281,7 +281,7 @@ sk_zero(_STACK *st)
 	memset(st->data, 0, sizeof(st->data)*st->num);
 	st->num = 0;
 }
-LCRYPTO_ALIAS(sk_zero)
+LCRYPTO_ALIAS(sk_zero);
 
 void
 sk_pop_free(_STACK *st, void (*func)(void *))
@@ -295,7 +295,7 @@ sk_pop_free(_STACK *st, void (*func)(void *))
 			func(st->data[i]);
 	sk_free(st);
 }
-LCRYPTO_ALIAS(sk_pop_free)
+LCRYPTO_ALIAS(sk_pop_free);
 
 void
 sk_free(_STACK *st)
@@ -305,7 +305,7 @@ sk_free(_STACK *st)
 	free(st->data);
 	free(st);
 }
-LCRYPTO_ALIAS(sk_free)
+LCRYPTO_ALIAS(sk_free);
 
 int
 sk_num(const _STACK *st)
@@ -314,7 +314,7 @@ sk_num(const _STACK *st)
 		return -1;
 	return st->num;
 }
-LCRYPTO_ALIAS(sk_num)
+LCRYPTO_ALIAS(sk_num);
 
 void *
 sk_value(const _STACK *st, int i)
@@ -323,7 +323,7 @@ sk_value(const _STACK *st, int i)
 		return NULL;
 	return st->data[i];
 }
-LCRYPTO_ALIAS(sk_value)
+LCRYPTO_ALIAS(sk_value);
 
 void *
 sk_set(_STACK *st, int i, void *value)
@@ -333,7 +333,7 @@ sk_set(_STACK *st, int i, void *value)
 	st->sorted = 0;
 	return (st->data[i] = value);
 }
-LCRYPTO_ALIAS(sk_set)
+LCRYPTO_ALIAS(sk_set);
 
 void
 sk_sort(_STACK *st)
@@ -351,7 +351,7 @@ sk_sort(_STACK *st)
 		st->sorted = 1;
 	}
 }
-LCRYPTO_ALIAS(sk_sort)
+LCRYPTO_ALIAS(sk_sort);
 
 int
 sk_is_sorted(const _STACK *st)
@@ -360,4 +360,4 @@ sk_is_sorted(const _STACK *st)
 		return 1;
 	return st->sorted;
 }
-LCRYPTO_ALIAS(sk_is_sorted)
+LCRYPTO_ALIAS(sk_is_sorted);
diff --git a/lib/libcrypto/ui/ui_err.c b/lib/libcrypto/ui/ui_err.c
index a1207fb0c38..3f875da7767 100644
--- a/lib/libcrypto/ui/ui_err.c
+++ b/lib/libcrypto/ui/ui_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ui_err.c,v 1.11 2022/11/12 13:16:10 beck Exp $ */
+/* $OpenBSD: ui_err.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2006 The OpenSSL Project.  All rights reserved.
  *
@@ -93,4 +93,4 @@ ERR_load_UI_strings(void)
 	}
 #endif
 }
-LCRYPTO_ALIAS(ERR_load_UI_strings)
+LCRYPTO_ALIAS(ERR_load_UI_strings);
diff --git a/lib/libcrypto/ui/ui_lib.c b/lib/libcrypto/ui/ui_lib.c
index 546540ad83e..73d899afcce 100644
--- a/lib/libcrypto/ui/ui_lib.c
+++ b/lib/libcrypto/ui/ui_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ui_lib.c,v 1.50 2022/12/23 02:31:56 jsing Exp $ */
+/* $OpenBSD: ui_lib.c,v 1.51 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL
  * project 2001.
  */
@@ -73,7 +73,7 @@ UI_new(void)
 {
 	return (UI_new_method(NULL));
 }
-LCRYPTO_ALIAS(UI_new)
+LCRYPTO_ALIAS(UI_new);
 
 UI *
 UI_new_method(const UI_METHOD *method)
@@ -90,7 +90,7 @@ UI_new_method(const UI_METHOD *method)
 
 	return ret;
 }
-LCRYPTO_ALIAS(UI_new_method)
+LCRYPTO_ALIAS(UI_new_method);
 
 static void
 free_string(UI_STRING *uis)
@@ -122,7 +122,7 @@ UI_free(UI *ui)
 	CRYPTO_free_ex_data(CRYPTO_EX_INDEX_UI, ui, &ui->ex_data);
 	free(ui);
 }
-LCRYPTO_ALIAS(UI_free)
+LCRYPTO_ALIAS(UI_free);
 
 static int
 allocate_string_stack(UI *ui)
@@ -269,7 +269,7 @@ UI_add_input_string(UI *ui, const char *prompt, int flags, char *result_buf,
 	return general_allocate_string(ui, prompt, 0, UIT_PROMPT, flags,
 	    result_buf, minsize, maxsize, NULL);
 }
-LCRYPTO_ALIAS(UI_add_input_string)
+LCRYPTO_ALIAS(UI_add_input_string);
 
 /* Same as UI_add_input_string(), excepts it takes a copy of the prompt. */
 int
@@ -279,7 +279,7 @@ UI_dup_input_string(UI *ui, const char *prompt, int flags, char *result_buf,
 	return general_allocate_string(ui, prompt, 1, UIT_PROMPT, flags,
 	    result_buf, minsize, maxsize, NULL);
 }
-LCRYPTO_ALIAS(UI_dup_input_string)
+LCRYPTO_ALIAS(UI_dup_input_string);
 
 int
 UI_add_verify_string(UI *ui, const char *prompt, int flags, char *result_buf,
@@ -288,7 +288,7 @@ UI_add_verify_string(UI *ui, const char *prompt, int flags, char *result_buf,
 	return general_allocate_string(ui, prompt, 0, UIT_VERIFY, flags,
 	    result_buf, minsize, maxsize, test_buf);
 }
-LCRYPTO_ALIAS(UI_add_verify_string)
+LCRYPTO_ALIAS(UI_add_verify_string);
 
 int
 UI_dup_verify_string(UI *ui, const char *prompt, int flags,
@@ -297,7 +297,7 @@ UI_dup_verify_string(UI *ui, const char *prompt, int flags,
 	return general_allocate_string(ui, prompt, 1, UIT_VERIFY, flags,
 	    result_buf, minsize, maxsize, test_buf);
 }
-LCRYPTO_ALIAS(UI_dup_verify_string)
+LCRYPTO_ALIAS(UI_dup_verify_string);
 
 int
 UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
@@ -306,7 +306,7 @@ UI_add_input_boolean(UI *ui, const char *prompt, const char *action_desc,
 	return general_allocate_boolean(ui, prompt, action_desc, ok_chars,
 	    cancel_chars, 0, UIT_BOOLEAN, flags, result_buf);
 }
-LCRYPTO_ALIAS(UI_add_input_boolean)
+LCRYPTO_ALIAS(UI_add_input_boolean);
 
 int
 UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
@@ -315,7 +315,7 @@ UI_dup_input_boolean(UI *ui, const char *prompt, const char *action_desc,
 	return general_allocate_boolean(ui, prompt, action_desc, ok_chars,
 	    cancel_chars, 1, UIT_BOOLEAN, flags, result_buf);
 }
-LCRYPTO_ALIAS(UI_dup_input_boolean)
+LCRYPTO_ALIAS(UI_dup_input_boolean);
 
 int
 UI_add_info_string(UI *ui, const char *text)
@@ -323,7 +323,7 @@ UI_add_info_string(UI *ui, const char *text)
 	return general_allocate_string(ui, text, 0, UIT_INFO, 0, NULL, 0, 0,
 	    NULL);
 }
-LCRYPTO_ALIAS(UI_add_info_string)
+LCRYPTO_ALIAS(UI_add_info_string);
 
 int
 UI_dup_info_string(UI *ui, const char *text)
@@ -331,7 +331,7 @@ UI_dup_info_string(UI *ui, const char *text)
 	return general_allocate_string(ui, text, 1, UIT_INFO, 0, NULL, 0, 0,
 	    NULL);
 }
-LCRYPTO_ALIAS(UI_dup_info_string)
+LCRYPTO_ALIAS(UI_dup_info_string);
 
 int
 UI_add_error_string(UI *ui, const char *text)
@@ -339,7 +339,7 @@ UI_add_error_string(UI *ui, const char *text)
 	return general_allocate_string(ui, text, 0, UIT_ERROR, 0, NULL, 0, 0,
 	    NULL);
 }
-LCRYPTO_ALIAS(UI_add_error_string)
+LCRYPTO_ALIAS(UI_add_error_string);
 
 int
 UI_dup_error_string(UI *ui, const char *text)
@@ -347,7 +347,7 @@ UI_dup_error_string(UI *ui, const char *text)
 	return general_allocate_string(ui, text, 1, UIT_ERROR, 0, NULL, 0, 0,
 	    NULL);
 }
-LCRYPTO_ALIAS(UI_dup_error_string)
+LCRYPTO_ALIAS(UI_dup_error_string);
 
 char *
 UI_construct_prompt(UI *ui, const char *object_desc, const char *object_name)
@@ -372,7 +372,7 @@ UI_construct_prompt(UI *ui, const char *object_desc, const char *object_name)
 
 	return prompt;
 }
-LCRYPTO_ALIAS(UI_construct_prompt)
+LCRYPTO_ALIAS(UI_construct_prompt);
 
 void *
 UI_add_user_data(UI *ui, void *user_data)
@@ -383,14 +383,14 @@ UI_add_user_data(UI *ui, void *user_data)
 
 	return old_data;
 }
-LCRYPTO_ALIAS(UI_add_user_data)
+LCRYPTO_ALIAS(UI_add_user_data);
 
 void *
 UI_get0_user_data(UI *ui)
 {
 	return ui->user_data;
 }
-LCRYPTO_ALIAS(UI_get0_user_data)
+LCRYPTO_ALIAS(UI_get0_user_data);
 
 const char *
 UI_get0_result(UI *ui, int i)
@@ -405,7 +405,7 @@ UI_get0_result(UI *ui, int i)
 	}
 	return UI_get0_result_string(sk_UI_STRING_value(ui->strings, i));
 }
-LCRYPTO_ALIAS(UI_get0_result)
+LCRYPTO_ALIAS(UI_get0_result);
 
 static int
 print_error(const char *str, size_t len, void *arg)
@@ -479,7 +479,7 @@ UI_process(UI *ui)
 		return -1;
 	return ok;
 }
-LCRYPTO_ALIAS(UI_process)
+LCRYPTO_ALIAS(UI_process);
 
 int
 UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void))
@@ -507,7 +507,7 @@ UI_ctrl(UI *ui, int cmd, long i, void *p, void (*f) (void))
 	UIerror(UI_R_UNKNOWN_CONTROL_COMMAND);
 	return -1;
 }
-LCRYPTO_ALIAS(UI_ctrl)
+LCRYPTO_ALIAS(UI_ctrl);
 
 int
 UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -516,28 +516,28 @@ UI_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_UI, argl, argp,
 	    new_func, dup_func, free_func);
 }
-LCRYPTO_ALIAS(UI_get_ex_new_index)
+LCRYPTO_ALIAS(UI_get_ex_new_index);
 
 int
 UI_set_ex_data(UI *r, int idx, void *arg)
 {
 	return (CRYPTO_set_ex_data(&r->ex_data, idx, arg));
 }
-LCRYPTO_ALIAS(UI_set_ex_data)
+LCRYPTO_ALIAS(UI_set_ex_data);
 
 void *
 UI_get_ex_data(UI *r, int idx)
 {
 	return (CRYPTO_get_ex_data(&r->ex_data, idx));
 }
-LCRYPTO_ALIAS(UI_get_ex_data)
+LCRYPTO_ALIAS(UI_get_ex_data);
 
 void
 UI_set_default_method(const UI_METHOD *method)
 {
 	default_UI_meth = method;
 }
-LCRYPTO_ALIAS(UI_set_default_method)
+LCRYPTO_ALIAS(UI_set_default_method);
 
 const UI_METHOD *
 UI_get_default_method(void)
@@ -547,14 +547,14 @@ UI_get_default_method(void)
 
 	return default_UI_meth;
 }
-LCRYPTO_ALIAS(UI_get_default_method)
+LCRYPTO_ALIAS(UI_get_default_method);
 
 const UI_METHOD *
 UI_get_method(UI *ui)
 {
 	return ui->meth;
 }
-LCRYPTO_ALIAS(UI_get_method)
+LCRYPTO_ALIAS(UI_get_method);
 
 const UI_METHOD *
 UI_set_method(UI *ui, const UI_METHOD *method)
@@ -563,7 +563,7 @@ UI_set_method(UI *ui, const UI_METHOD *method)
 
 	return ui->meth;
 }
-LCRYPTO_ALIAS(UI_set_method)
+LCRYPTO_ALIAS(UI_set_method);
 
 UI_METHOD *
 UI_create_method(const char *name)
@@ -585,7 +585,7 @@ UI_create_method(const char *name)
 
 	return NULL;
 }
-LCRYPTO_ALIAS(UI_create_method)
+LCRYPTO_ALIAS(UI_create_method);
 
 void
 UI_destroy_method(UI_METHOD *method)
@@ -596,7 +596,7 @@ UI_destroy_method(UI_METHOD *method)
 	free(method->name);
 	free(method);
 }
-LCRYPTO_ALIAS(UI_destroy_method)
+LCRYPTO_ALIAS(UI_destroy_method);
 
 int
 UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui))
@@ -608,7 +608,7 @@ UI_method_set_opener(UI_METHOD *method, int (*opener)(UI *ui))
 
 	return 0;
 }
-LCRYPTO_ALIAS(UI_method_set_opener)
+LCRYPTO_ALIAS(UI_method_set_opener);
 
 int
 UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis))
@@ -620,7 +620,7 @@ UI_method_set_writer(UI_METHOD *method, int (*writer)(UI *ui, UI_STRING *uis))
 
 	return 0;
 }
-LCRYPTO_ALIAS(UI_method_set_writer)
+LCRYPTO_ALIAS(UI_method_set_writer);
 
 int
 UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui))
@@ -632,7 +632,7 @@ UI_method_set_flusher(UI_METHOD *method, int (*flusher)(UI *ui))
 
 	return 0;
 }
-LCRYPTO_ALIAS(UI_method_set_flusher)
+LCRYPTO_ALIAS(UI_method_set_flusher);
 
 int
 UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis))
@@ -644,7 +644,7 @@ UI_method_set_reader(UI_METHOD *method, int (*reader)(UI *ui, UI_STRING *uis))
 
 	return 0;
 }
-LCRYPTO_ALIAS(UI_method_set_reader)
+LCRYPTO_ALIAS(UI_method_set_reader);
 
 int
 UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui))
@@ -656,7 +656,7 @@ UI_method_set_closer(UI_METHOD *method, int (*closer)(UI *ui))
 
 	return 0;
 }
-LCRYPTO_ALIAS(UI_method_set_closer)
+LCRYPTO_ALIAS(UI_method_set_closer);
 
 int
 UI_method_set_prompt_constructor(UI_METHOD *method,
@@ -670,7 +670,7 @@ UI_method_set_prompt_constructor(UI_METHOD *method,
 
 	return 0;
 }
-LCRYPTO_ALIAS(UI_method_set_prompt_constructor)
+LCRYPTO_ALIAS(UI_method_set_prompt_constructor);
 
 int
 (*UI_method_get_opener(const UI_METHOD * method))(UI *)
@@ -680,7 +680,7 @@ int
 
 	return method->ui_open_session;
 }
-LCRYPTO_ALIAS(UI_method_get_opener)
+LCRYPTO_ALIAS(UI_method_get_opener);
 
 int
 (*UI_method_get_writer(const UI_METHOD *method))(UI *, UI_STRING *)
@@ -690,7 +690,7 @@ int
 
 	return method->ui_write_string;
 }
-LCRYPTO_ALIAS(UI_method_get_writer)
+LCRYPTO_ALIAS(UI_method_get_writer);
 
 int
 (*UI_method_get_flusher(const UI_METHOD *method)) (UI *)
@@ -700,7 +700,7 @@ int
 
 	return method->ui_flush;
 }
-LCRYPTO_ALIAS(UI_method_get_flusher)
+LCRYPTO_ALIAS(UI_method_get_flusher);
 
 int
 (*UI_method_get_reader(const UI_METHOD *method))(UI *, UI_STRING *)
@@ -710,7 +710,7 @@ int
 
 	return method->ui_read_string;
 }
-LCRYPTO_ALIAS(UI_method_get_reader)
+LCRYPTO_ALIAS(UI_method_get_reader);
 
 int
 (*UI_method_get_closer(const UI_METHOD *method))(UI *)
@@ -720,7 +720,7 @@ int
 
 	return method->ui_close_session;
 }
-LCRYPTO_ALIAS(UI_method_get_closer)
+LCRYPTO_ALIAS(UI_method_get_closer);
 
 char *
 (*UI_method_get_prompt_constructor(const UI_METHOD *method))(UI *, const char *,
@@ -731,7 +731,7 @@ char *
 
 	return method->ui_construct_prompt;
 }
-LCRYPTO_ALIAS(UI_method_get_prompt_constructor)
+LCRYPTO_ALIAS(UI_method_get_prompt_constructor);
 
 enum UI_string_types
 UI_get_string_type(UI_STRING *uis)
@@ -741,7 +741,7 @@ UI_get_string_type(UI_STRING *uis)
 
 	return uis->type;
 }
-LCRYPTO_ALIAS(UI_get_string_type)
+LCRYPTO_ALIAS(UI_get_string_type);
 
 int
 UI_get_input_flags(UI_STRING *uis)
@@ -751,7 +751,7 @@ UI_get_input_flags(UI_STRING *uis)
 
 	return uis->input_flags;
 }
-LCRYPTO_ALIAS(UI_get_input_flags)
+LCRYPTO_ALIAS(UI_get_input_flags);
 
 const char *
 UI_get0_output_string(UI_STRING *uis)
@@ -761,7 +761,7 @@ UI_get0_output_string(UI_STRING *uis)
 
 	return uis->out_string;
 }
-LCRYPTO_ALIAS(UI_get0_output_string)
+LCRYPTO_ALIAS(UI_get0_output_string);
 
 const char *
 UI_get0_action_string(UI_STRING *uis)
@@ -777,7 +777,7 @@ UI_get0_action_string(UI_STRING *uis)
 		return NULL;
 	}
 }
-LCRYPTO_ALIAS(UI_get0_action_string)
+LCRYPTO_ALIAS(UI_get0_action_string);
 
 const char *
 UI_get0_result_string(UI_STRING *uis)
@@ -793,7 +793,7 @@ UI_get0_result_string(UI_STRING *uis)
 		return NULL;
 	}
 }
-LCRYPTO_ALIAS(UI_get0_result_string)
+LCRYPTO_ALIAS(UI_get0_result_string);
 
 const char *
 UI_get0_test_string(UI_STRING *uis)
@@ -808,7 +808,7 @@ UI_get0_test_string(UI_STRING *uis)
 		return NULL;
 	}
 }
-LCRYPTO_ALIAS(UI_get0_test_string)
+LCRYPTO_ALIAS(UI_get0_test_string);
 
 int
 UI_get_result_minsize(UI_STRING *uis)
@@ -824,7 +824,7 @@ UI_get_result_minsize(UI_STRING *uis)
 		return -1;
 	}
 }
-LCRYPTO_ALIAS(UI_get_result_minsize)
+LCRYPTO_ALIAS(UI_get_result_minsize);
 
 int
 UI_get_result_maxsize(UI_STRING *uis)
@@ -840,7 +840,7 @@ UI_get_result_maxsize(UI_STRING *uis)
 		return -1;
 	}
 }
-LCRYPTO_ALIAS(UI_get_result_maxsize)
+LCRYPTO_ALIAS(UI_get_result_maxsize);
 
 int
 UI_set_result(UI *ui, UI_STRING *uis, const char *result)
@@ -904,4 +904,4 @@ UI_set_result(UI *ui, UI_STRING *uis, const char *result)
 	}
 	return 0;
 }
-LCRYPTO_ALIAS(UI_set_result)
+LCRYPTO_ALIAS(UI_set_result);
diff --git a/lib/libcrypto/ui/ui_null.c b/lib/libcrypto/ui/ui_null.c
index 7bb7a90b2fb..cbc9a5025bf 100644
--- a/lib/libcrypto/ui/ui_null.c
+++ b/lib/libcrypto/ui/ui_null.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ui_null.c,v 1.1 2022/12/17 21:59:39 tb Exp $ */
+/*	$OpenBSD: ui_null.c,v 1.2 2023/02/16 08:38:17 tb Exp $ */
 
 /*
  * Written by Theo Buehler. Public domain.
@@ -15,4 +15,4 @@ UI_null(void)
 {
 	return &ui_null;
 }
-LCRYPTO_ALIAS(UI_null)
+LCRYPTO_ALIAS(UI_null);
diff --git a/lib/libcrypto/ui/ui_openssl.c b/lib/libcrypto/ui/ui_openssl.c
index 0d2e6f1ac86..0b91700571a 100644
--- a/lib/libcrypto/ui/ui_openssl.c
+++ b/lib/libcrypto/ui/ui_openssl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ui_openssl.c,v 1.27 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: ui_openssl.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Richard Levitte (richard@levitte.org) and others
  * for the OpenSSL project 2001.
  */
@@ -167,7 +167,7 @@ UI_OpenSSL(void)
 {
 	return &ui_openssl;
 }
-LCRYPTO_ALIAS(UI_OpenSSL)
+LCRYPTO_ALIAS(UI_OpenSSL);
 
 /* The following function makes sure that info and error strings are printed
    before any prompt. */
diff --git a/lib/libcrypto/ui/ui_util.c b/lib/libcrypto/ui/ui_util.c
index 5e7048531cc..4fa4058cd46 100644
--- a/lib/libcrypto/ui/ui_util.c
+++ b/lib/libcrypto/ui/ui_util.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ui_util.c,v 1.13 2022/12/23 02:20:28 jsing Exp $ */
+/* $OpenBSD: ui_util.c,v 1.14 2023/02/16 08:38:17 tb Exp $ */
 /* ====================================================================
  * Copyright (c) 2001-2002 The OpenSSL Project.  All rights reserved.
  *
@@ -70,7 +70,7 @@ UI_UTIL_read_pw_string(char *buf, int length, const char *prompt, int verify)
 	explicit_bzero(buff, BUFSIZ);
 	return (ret);
 }
-LCRYPTO_ALIAS(UI_UTIL_read_pw_string)
+LCRYPTO_ALIAS(UI_UTIL_read_pw_string);
 
 int
 UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt, int verify)
@@ -95,4 +95,4 @@ UI_UTIL_read_pw(char *buf, char *buff, int size, const char *prompt, int verify)
 		ok = 0;
 	return (ok);
 }
-LCRYPTO_ALIAS(UI_UTIL_read_pw)
+LCRYPTO_ALIAS(UI_UTIL_read_pw);
diff --git a/lib/libcrypto/x509/by_dir.c b/lib/libcrypto/x509/by_dir.c
index 341c252ea94..9fa6a100480 100644
--- a/lib/libcrypto/x509/by_dir.c
+++ b/lib/libcrypto/x509/by_dir.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: by_dir.c,v 1.43 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: by_dir.c,v 1.44 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -117,7 +117,7 @@ X509_LOOKUP_hash_dir(void)
 {
 	return &x509_dir_lookup;
 }
-LCRYPTO_ALIAS(X509_LOOKUP_hash_dir)
+LCRYPTO_ALIAS(X509_LOOKUP_hash_dir);
 
 static int
 dir_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
diff --git a/lib/libcrypto/x509/by_file.c b/lib/libcrypto/x509/by_file.c
index 70a2a62a97a..606f4c8d0c9 100644
--- a/lib/libcrypto/x509/by_file.c
+++ b/lib/libcrypto/x509/by_file.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: by_file.c,v 1.27 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: by_file.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -89,7 +89,7 @@ X509_LOOKUP_file(void)
 {
 	return &x509_file_lookup;
 }
-LCRYPTO_ALIAS(X509_LOOKUP_file)
+LCRYPTO_ALIAS(X509_LOOKUP_file);
 
 static int
 by_file_ctrl(X509_LOOKUP *ctx, int cmd, const char *argp, long argl,
@@ -174,7 +174,7 @@ err:
 	BIO_free(in);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_load_cert_file)
+LCRYPTO_ALIAS(X509_load_cert_file);
 
 int
 X509_load_crl_file(X509_LOOKUP *ctx, const char *file, int type)
@@ -231,7 +231,7 @@ err:
 	BIO_free(in);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_load_crl_file)
+LCRYPTO_ALIAS(X509_load_crl_file);
 
 int
 X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type)
@@ -270,4 +270,4 @@ X509_load_cert_crl_file(X509_LOOKUP *ctx, const char *file, int type)
 	sk_X509_INFO_pop_free(inf, X509_INFO_free);
 	return count;
 }
-LCRYPTO_ALIAS(X509_load_cert_crl_file)
+LCRYPTO_ALIAS(X509_load_cert_crl_file);
diff --git a/lib/libcrypto/x509/by_mem.c b/lib/libcrypto/x509/by_mem.c
index 8f0a93fce3e..579eecd36de 100644
--- a/lib/libcrypto/x509/by_mem.c
+++ b/lib/libcrypto/x509/by_mem.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: by_mem.c,v 1.7 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: by_mem.c,v 1.8 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -90,7 +90,7 @@ X509_LOOKUP_mem(void)
 {
 	return (&x509_mem_lookup);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_mem)
+LCRYPTO_ALIAS(X509_LOOKUP_mem);
 
 static int
 by_mem_ctrl(X509_LOOKUP *lu, int cmd, const char *buf,
diff --git a/lib/libcrypto/x509/pcy_lib.c b/lib/libcrypto/x509/pcy_lib.c
index e4b06e988bc..e4d3fd9fa84 100644
--- a/lib/libcrypto/x509/pcy_lib.c
+++ b/lib/libcrypto/x509/pcy_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pcy_lib.c,v 1.2 2022/11/14 17:48:49 beck Exp $ */
+/* $OpenBSD: pcy_lib.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2004.
  */
@@ -72,7 +72,7 @@ X509_policy_tree_level_count(const X509_POLICY_TREE *tree)
 		return 0;
 	return tree->nlevel;
 }
-LCRYPTO_ALIAS(X509_policy_tree_level_count)
+LCRYPTO_ALIAS(X509_policy_tree_level_count);
 
 X509_POLICY_LEVEL *
 X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i)
@@ -81,7 +81,7 @@ X509_policy_tree_get0_level(const X509_POLICY_TREE *tree, int i)
 		return NULL;
 	return tree->levels + i;
 }
-LCRYPTO_ALIAS(X509_policy_tree_get0_level)
+LCRYPTO_ALIAS(X509_policy_tree_get0_level);
 
 STACK_OF(X509_POLICY_NODE) *
 X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree)
@@ -90,7 +90,7 @@ X509_policy_tree_get0_policies(const X509_POLICY_TREE *tree)
 		return NULL;
 	return tree->auth_policies;
 }
-LCRYPTO_ALIAS(X509_policy_tree_get0_policies)
+LCRYPTO_ALIAS(X509_policy_tree_get0_policies);
 
 STACK_OF(X509_POLICY_NODE) *
 X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree)
@@ -102,7 +102,7 @@ X509_policy_tree_get0_user_policies(const X509_POLICY_TREE *tree)
 	else
 		return tree->user_policies;
 }
-LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies)
+LCRYPTO_ALIAS(X509_policy_tree_get0_user_policies);
 
 /* X509_POLICY_LEVEL stuff */
 
@@ -120,7 +120,7 @@ X509_policy_level_node_count(X509_POLICY_LEVEL *level)
 		n += sk_X509_POLICY_NODE_num(level->nodes);
 	return n;
 }
-LCRYPTO_ALIAS(X509_policy_level_node_count)
+LCRYPTO_ALIAS(X509_policy_level_node_count);
 
 X509_POLICY_NODE *
 X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i)
@@ -134,7 +134,7 @@ X509_policy_level_get0_node(X509_POLICY_LEVEL *level, int i)
 	}
 	return sk_X509_POLICY_NODE_value(level->nodes, i);
 }
-LCRYPTO_ALIAS(X509_policy_level_get0_node)
+LCRYPTO_ALIAS(X509_policy_level_get0_node);
 
 /* X509_POLICY_NODE stuff */
 
@@ -145,7 +145,7 @@ X509_policy_node_get0_policy(const X509_POLICY_NODE *node)
 		return NULL;
 	return node->data->valid_policy;
 }
-LCRYPTO_ALIAS(X509_policy_node_get0_policy)
+LCRYPTO_ALIAS(X509_policy_node_get0_policy);
 
 STACK_OF(POLICYQUALINFO) *
 X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node)
@@ -154,7 +154,7 @@ X509_policy_node_get0_qualifiers(const X509_POLICY_NODE *node)
 		return NULL;
 	return node->data->qualifier_set;
 }
-LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers)
+LCRYPTO_ALIAS(X509_policy_node_get0_qualifiers);
 
 const X509_POLICY_NODE *
 X509_policy_node_get0_parent(const X509_POLICY_NODE *node)
@@ -163,4 +163,4 @@ X509_policy_node_get0_parent(const X509_POLICY_NODE *node)
 		return NULL;
 	return node->parent;
 }
-LCRYPTO_ALIAS(X509_policy_node_get0_parent)
+LCRYPTO_ALIAS(X509_policy_node_get0_parent);
diff --git a/lib/libcrypto/x509/pcy_tree.c b/lib/libcrypto/x509/pcy_tree.c
index 050503bdf3f..56e05910cd6 100644
--- a/lib/libcrypto/x509/pcy_tree.c
+++ b/lib/libcrypto/x509/pcy_tree.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: pcy_tree.c,v 1.5 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: pcy_tree.c,v 1.6 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2004.
  */
@@ -657,7 +657,7 @@ X509_policy_tree_free(X509_POLICY_TREE *tree)
 	free(tree->levels);
 	free(tree);
 }
-LCRYPTO_ALIAS(X509_policy_tree_free)
+LCRYPTO_ALIAS(X509_policy_tree_free);
 
 /* Application policy checking function.
  * Return codes:
@@ -770,4 +770,4 @@ error:
 
 	return 0;
 }
-LCRYPTO_ALIAS(X509_policy_check)
+LCRYPTO_ALIAS(X509_policy_check);
diff --git a/lib/libcrypto/x509/x509_addr.c b/lib/libcrypto/x509/x509_addr.c
index 510ea4e697f..2d8cc0b3180 100644
--- a/lib/libcrypto/x509/x509_addr.c
+++ b/lib/libcrypto/x509/x509_addr.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: x509_addr.c,v 1.85 2022/11/26 16:08:54 tb Exp $ */
+/*	$OpenBSD: x509_addr.c,v 1.86 2023/02/16 08:38:17 tb Exp $ */
 /*
  * Contributed to the OpenSSL Project by the American Registry for
  * Internet Numbers ("ARIN").
@@ -215,28 +215,28 @@ d2i_IPAddressRange(IPAddressRange **a, const unsigned char **in, long len)
 	return (IPAddressRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &IPAddressRange_it);
 }
-LCRYPTO_ALIAS(d2i_IPAddressRange)
+LCRYPTO_ALIAS(d2i_IPAddressRange);
 
 int
 i2d_IPAddressRange(IPAddressRange *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressRange_it);
 }
-LCRYPTO_ALIAS(i2d_IPAddressRange)
+LCRYPTO_ALIAS(i2d_IPAddressRange);
 
 IPAddressRange *
 IPAddressRange_new(void)
 {
 	return (IPAddressRange *)ASN1_item_new(&IPAddressRange_it);
 }
-LCRYPTO_ALIAS(IPAddressRange_new)
+LCRYPTO_ALIAS(IPAddressRange_new);
 
 void
 IPAddressRange_free(IPAddressRange *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &IPAddressRange_it);
 }
-LCRYPTO_ALIAS(IPAddressRange_free)
+LCRYPTO_ALIAS(IPAddressRange_free);
 
 IPAddressOrRange *
 d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len)
@@ -244,28 +244,28 @@ d2i_IPAddressOrRange(IPAddressOrRange **a, const unsigned char **in, long len)
 	return (IPAddressOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &IPAddressOrRange_it);
 }
-LCRYPTO_ALIAS(d2i_IPAddressOrRange)
+LCRYPTO_ALIAS(d2i_IPAddressOrRange);
 
 int
 i2d_IPAddressOrRange(IPAddressOrRange *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressOrRange_it);
 }
-LCRYPTO_ALIAS(i2d_IPAddressOrRange)
+LCRYPTO_ALIAS(i2d_IPAddressOrRange);
 
 IPAddressOrRange *
 IPAddressOrRange_new(void)
 {
 	return (IPAddressOrRange *)ASN1_item_new(&IPAddressOrRange_it);
 }
-LCRYPTO_ALIAS(IPAddressOrRange_new)
+LCRYPTO_ALIAS(IPAddressOrRange_new);
 
 void
 IPAddressOrRange_free(IPAddressOrRange *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &IPAddressOrRange_it);
 }
-LCRYPTO_ALIAS(IPAddressOrRange_free)
+LCRYPTO_ALIAS(IPAddressOrRange_free);
 
 IPAddressChoice *
 d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len)
@@ -273,28 +273,28 @@ d2i_IPAddressChoice(IPAddressChoice **a, const unsigned char **in, long len)
 	return (IPAddressChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &IPAddressChoice_it);
 }
-LCRYPTO_ALIAS(d2i_IPAddressChoice)
+LCRYPTO_ALIAS(d2i_IPAddressChoice);
 
 int
 i2d_IPAddressChoice(IPAddressChoice *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressChoice_it);
 }
-LCRYPTO_ALIAS(i2d_IPAddressChoice)
+LCRYPTO_ALIAS(i2d_IPAddressChoice);
 
 IPAddressChoice *
 IPAddressChoice_new(void)
 {
 	return (IPAddressChoice *)ASN1_item_new(&IPAddressChoice_it);
 }
-LCRYPTO_ALIAS(IPAddressChoice_new)
+LCRYPTO_ALIAS(IPAddressChoice_new);
 
 void
 IPAddressChoice_free(IPAddressChoice *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &IPAddressChoice_it);
 }
-LCRYPTO_ALIAS(IPAddressChoice_free)
+LCRYPTO_ALIAS(IPAddressChoice_free);
 
 IPAddressFamily *
 d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len)
@@ -302,28 +302,28 @@ d2i_IPAddressFamily(IPAddressFamily **a, const unsigned char **in, long len)
 	return (IPAddressFamily *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &IPAddressFamily_it);
 }
-LCRYPTO_ALIAS(d2i_IPAddressFamily)
+LCRYPTO_ALIAS(d2i_IPAddressFamily);
 
 int
 i2d_IPAddressFamily(IPAddressFamily *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &IPAddressFamily_it);
 }
-LCRYPTO_ALIAS(i2d_IPAddressFamily)
+LCRYPTO_ALIAS(i2d_IPAddressFamily);
 
 IPAddressFamily *
 IPAddressFamily_new(void)
 {
 	return (IPAddressFamily *)ASN1_item_new(&IPAddressFamily_it);
 }
-LCRYPTO_ALIAS(IPAddressFamily_new)
+LCRYPTO_ALIAS(IPAddressFamily_new);
 
 void
 IPAddressFamily_free(IPAddressFamily *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &IPAddressFamily_it);
 }
-LCRYPTO_ALIAS(IPAddressFamily_free)
+LCRYPTO_ALIAS(IPAddressFamily_free);
 
 /*
  * Convenience accessors for IPAddressFamily.
@@ -534,7 +534,7 @@ X509v3_addr_get_afi(const IPAddressFamily *af)
 
 	return afi;
 }
-LCRYPTO_ALIAS(X509v3_addr_get_afi)
+LCRYPTO_ALIAS(X509v3_addr_get_afi);
 
 /*
  * Expand the bitstring form (RFC 3779, section 2.1.2) of an address into
@@ -1110,7 +1110,7 @@ X509v3_addr_add_inherit(IPAddrBlocks *addr, const unsigned afi,
 
 	return IPAddressFamily_set_inheritance(af);
 }
-LCRYPTO_ALIAS(X509v3_addr_add_inherit)
+LCRYPTO_ALIAS(X509v3_addr_add_inherit);
 
 /*
  * Construct an IPAddressOrRange sequence, or return an existing one.
@@ -1174,7 +1174,7 @@ X509v3_addr_add_prefix(IPAddrBlocks *addr, const unsigned afi,
 
 	return 1;
 }
-LCRYPTO_ALIAS(X509v3_addr_add_prefix)
+LCRYPTO_ALIAS(X509v3_addr_add_prefix);
 
 /*
  * Add a range.
@@ -1202,7 +1202,7 @@ X509v3_addr_add_range(IPAddrBlocks *addr, const unsigned afi,
 
 	return 1;
 }
-LCRYPTO_ALIAS(X509v3_addr_add_range)
+LCRYPTO_ALIAS(X509v3_addr_add_range);
 
 static int
 extract_min_max_bitstr(IPAddressOrRange *aor, ASN1_BIT_STRING **out_min,
@@ -1262,7 +1262,7 @@ X509v3_addr_get_range(IPAddressOrRange *aor, const unsigned afi,
 
 	return afi_len;
 }
-LCRYPTO_ALIAS(X509v3_addr_get_range)
+LCRYPTO_ALIAS(X509v3_addr_get_range);
 
 /*
  * Check whether an IPAddrBLocks is in canonical form.
@@ -1381,7 +1381,7 @@ X509v3_addr_is_canonical(IPAddrBlocks *addr)
 	 */
 	return 1;
 }
-LCRYPTO_ALIAS(X509v3_addr_is_canonical)
+LCRYPTO_ALIAS(X509v3_addr_is_canonical);
 
 /*
  * Whack an IPAddressOrRanges into canonical form.
@@ -1488,7 +1488,7 @@ X509v3_addr_canonize(IPAddrBlocks *addr)
 
 	return X509v3_addr_is_canonical(addr);
 }
-LCRYPTO_ALIAS(X509v3_addr_canonize)
+LCRYPTO_ALIAS(X509v3_addr_canonize);
 
 /*
  * v2i handler for the IPAddrBlocks extension.
@@ -1732,7 +1732,7 @@ X509v3_addr_inherits(IPAddrBlocks *addr)
 
 	return 0;
 }
-LCRYPTO_ALIAS(X509v3_addr_inherits)
+LCRYPTO_ALIAS(X509v3_addr_inherits);
 
 /*
  * Figure out whether parent contains child.
@@ -1816,7 +1816,7 @@ X509v3_addr_subset(IPAddrBlocks *child, IPAddrBlocks *parent)
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509v3_addr_subset)
+LCRYPTO_ALIAS(X509v3_addr_subset);
 
 static int
 verify_error(X509_STORE_CTX *ctx, X509 *cert, int error, int depth)
@@ -2022,7 +2022,7 @@ X509v3_addr_validate_path(X509_STORE_CTX *ctx)
 	}
 	return addr_validate_path_internal(ctx, ctx->chain, NULL);
 }
-LCRYPTO_ALIAS(X509v3_addr_validate_path)
+LCRYPTO_ALIAS(X509v3_addr_validate_path);
 
 /*
  * RFC 3779 2.3 path validation of an extension.
@@ -2040,6 +2040,6 @@ X509v3_addr_validate_resource_set(STACK_OF(X509) *chain, IPAddrBlocks *ext,
 		return 0;
 	return addr_validate_path_internal(NULL, chain, ext);
 }
-LCRYPTO_ALIAS(X509v3_addr_validate_resource_set)
+LCRYPTO_ALIAS(X509v3_addr_validate_resource_set);
 
 #endif /* OPENSSL_NO_RFC3779 */
diff --git a/lib/libcrypto/x509/x509_akeya.c b/lib/libcrypto/x509/x509_akeya.c
index 969cad1c3e1..52eca42cffd 100644
--- a/lib/libcrypto/x509/x509_akeya.c
+++ b/lib/libcrypto/x509/x509_akeya.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_akeya.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_akeya.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -104,25 +104,25 @@ d2i_AUTHORITY_KEYID(AUTHORITY_KEYID **a, const unsigned char **in, long len)
 	return (AUTHORITY_KEYID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &AUTHORITY_KEYID_it);
 }
-LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID)
+LCRYPTO_ALIAS(d2i_AUTHORITY_KEYID);
 
 int
 i2d_AUTHORITY_KEYID(AUTHORITY_KEYID *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_KEYID_it);
 }
-LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID)
+LCRYPTO_ALIAS(i2d_AUTHORITY_KEYID);
 
 AUTHORITY_KEYID *
 AUTHORITY_KEYID_new(void)
 {
 	return (AUTHORITY_KEYID *)ASN1_item_new(&AUTHORITY_KEYID_it);
 }
-LCRYPTO_ALIAS(AUTHORITY_KEYID_new)
+LCRYPTO_ALIAS(AUTHORITY_KEYID_new);
 
 void
 AUTHORITY_KEYID_free(AUTHORITY_KEYID *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_KEYID_it);
 }
-LCRYPTO_ALIAS(AUTHORITY_KEYID_free)
+LCRYPTO_ALIAS(AUTHORITY_KEYID_free);
diff --git a/lib/libcrypto/x509/x509_alt.c b/lib/libcrypto/x509/x509_alt.c
index 137a1c1c11e..c4c5fcabe74 100644
--- a/lib/libcrypto/x509/x509_alt.c
+++ b/lib/libcrypto/x509/x509_alt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_alt.c,v 1.14 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_alt.c,v 1.15 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -152,7 +152,7 @@ i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method, GENERAL_NAMES *gens,
 
 	return NULL;
 }
-LCRYPTO_ALIAS(i2v_GENERAL_NAMES)
+LCRYPTO_ALIAS(i2v_GENERAL_NAMES);
 
 STACK_OF(CONF_VALUE) *
 i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen,
@@ -245,7 +245,7 @@ i2v_GENERAL_NAME(X509V3_EXT_METHOD *method, GENERAL_NAME *gen,
 
 	return NULL;
 }
-LCRYPTO_ALIAS(i2v_GENERAL_NAME)
+LCRYPTO_ALIAS(i2v_GENERAL_NAME);
 
 int
 GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
@@ -312,7 +312,7 @@ GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_print)
+LCRYPTO_ALIAS(GENERAL_NAME_print);
 
 static GENERAL_NAMES *
 v2i_issuer_alt(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -515,7 +515,7 @@ err:
 	sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 	return NULL;
 }
-LCRYPTO_ALIAS(v2i_GENERAL_NAMES)
+LCRYPTO_ALIAS(v2i_GENERAL_NAMES);
 
 GENERAL_NAME *
 v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -523,7 +523,7 @@ v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
 {
 	return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0);
 }
-LCRYPTO_ALIAS(v2i_GENERAL_NAME)
+LCRYPTO_ALIAS(v2i_GENERAL_NAME);
 
 GENERAL_NAME *
 a2i_GENERAL_NAME(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
@@ -614,7 +614,7 @@ err:
 		GENERAL_NAME_free(gen);
 	return NULL;
 }
-LCRYPTO_ALIAS(a2i_GENERAL_NAME)
+LCRYPTO_ALIAS(a2i_GENERAL_NAME);
 
 GENERAL_NAME *
 v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
@@ -718,7 +718,7 @@ v2i_GENERAL_NAME_ex(GENERAL_NAME *out, const X509V3_EXT_METHOD *method,
 		GENERAL_NAME_free(ret);
 	return NULL;
 }
-LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex)
+LCRYPTO_ALIAS(v2i_GENERAL_NAME_ex);
 
 static int
 do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
diff --git a/lib/libcrypto/x509/x509_asid.c b/lib/libcrypto/x509/x509_asid.c
index 3a37b002f2b..cc36cc1a566 100644
--- a/lib/libcrypto/x509/x509_asid.c
+++ b/lib/libcrypto/x509/x509_asid.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: x509_asid.c,v 1.38 2022/11/26 16:08:54 tb Exp $ */
+/*	$OpenBSD: x509_asid.c,v 1.39 2023/02/16 08:38:17 tb Exp $ */
 /*
  * Contributed to the OpenSSL Project by the American Registry for
  * Internet Numbers ("ARIN").
@@ -191,28 +191,28 @@ d2i_ASRange(ASRange **a, const unsigned char **in, long len)
 	return (ASRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ASRange_it);
 }
-LCRYPTO_ALIAS(d2i_ASRange)
+LCRYPTO_ALIAS(d2i_ASRange);
 
 int
 i2d_ASRange(ASRange *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASRange_it);
 }
-LCRYPTO_ALIAS(i2d_ASRange)
+LCRYPTO_ALIAS(i2d_ASRange);
 
 ASRange *
 ASRange_new(void)
 {
 	return (ASRange *)ASN1_item_new(&ASRange_it);
 }
-LCRYPTO_ALIAS(ASRange_new)
+LCRYPTO_ALIAS(ASRange_new);
 
 void
 ASRange_free(ASRange *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ASRange_it);
 }
-LCRYPTO_ALIAS(ASRange_free)
+LCRYPTO_ALIAS(ASRange_free);
 
 ASIdOrRange *
 d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len)
@@ -220,28 +220,28 @@ d2i_ASIdOrRange(ASIdOrRange **a, const unsigned char **in, long len)
 	return (ASIdOrRange *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ASIdOrRange_it);
 }
-LCRYPTO_ALIAS(d2i_ASIdOrRange)
+LCRYPTO_ALIAS(d2i_ASIdOrRange);
 
 int
 i2d_ASIdOrRange(ASIdOrRange *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdOrRange_it);
 }
-LCRYPTO_ALIAS(i2d_ASIdOrRange)
+LCRYPTO_ALIAS(i2d_ASIdOrRange);
 
 ASIdOrRange *
 ASIdOrRange_new(void)
 {
 	return (ASIdOrRange *)ASN1_item_new(&ASIdOrRange_it);
 }
-LCRYPTO_ALIAS(ASIdOrRange_new)
+LCRYPTO_ALIAS(ASIdOrRange_new);
 
 void
 ASIdOrRange_free(ASIdOrRange *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ASIdOrRange_it);
 }
-LCRYPTO_ALIAS(ASIdOrRange_free)
+LCRYPTO_ALIAS(ASIdOrRange_free);
 
 ASIdentifierChoice *
 d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in,
@@ -250,28 +250,28 @@ d2i_ASIdentifierChoice(ASIdentifierChoice **a, const unsigned char **in,
 	return (ASIdentifierChoice *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ASIdentifierChoice_it);
 }
-LCRYPTO_ALIAS(d2i_ASIdentifierChoice)
+LCRYPTO_ALIAS(d2i_ASIdentifierChoice);
 
 int
 i2d_ASIdentifierChoice(ASIdentifierChoice *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifierChoice_it);
 }
-LCRYPTO_ALIAS(i2d_ASIdentifierChoice)
+LCRYPTO_ALIAS(i2d_ASIdentifierChoice);
 
 ASIdentifierChoice *
 ASIdentifierChoice_new(void)
 {
 	return (ASIdentifierChoice *)ASN1_item_new(&ASIdentifierChoice_it);
 }
-LCRYPTO_ALIAS(ASIdentifierChoice_new)
+LCRYPTO_ALIAS(ASIdentifierChoice_new);
 
 void
 ASIdentifierChoice_free(ASIdentifierChoice *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ASIdentifierChoice_it);
 }
-LCRYPTO_ALIAS(ASIdentifierChoice_free)
+LCRYPTO_ALIAS(ASIdentifierChoice_free);
 
 ASIdentifiers *
 d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len)
@@ -279,28 +279,28 @@ d2i_ASIdentifiers(ASIdentifiers **a, const unsigned char **in, long len)
 	return (ASIdentifiers *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ASIdentifiers_it);
 }
-LCRYPTO_ALIAS(d2i_ASIdentifiers)
+LCRYPTO_ALIAS(d2i_ASIdentifiers);
 
 int
 i2d_ASIdentifiers(ASIdentifiers *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ASIdentifiers_it);
 }
-LCRYPTO_ALIAS(i2d_ASIdentifiers)
+LCRYPTO_ALIAS(i2d_ASIdentifiers);
 
 ASIdentifiers *
 ASIdentifiers_new(void)
 {
 	return (ASIdentifiers *)ASN1_item_new(&ASIdentifiers_it);
 }
-LCRYPTO_ALIAS(ASIdentifiers_new)
+LCRYPTO_ALIAS(ASIdentifiers_new);
 
 void
 ASIdentifiers_free(ASIdentifiers *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ASIdentifiers_it);
 }
-LCRYPTO_ALIAS(ASIdentifiers_free)
+LCRYPTO_ALIAS(ASIdentifiers_free);
 
 /*
  * i2r method for an ASIdentifierChoice.
@@ -428,7 +428,7 @@ X509v3_asid_add_inherit(ASIdentifiers *asid, int which)
 	}
 	return (*choice)->type == ASIdentifierChoice_inherit;
 }
-LCRYPTO_ALIAS(X509v3_asid_add_inherit)
+LCRYPTO_ALIAS(X509v3_asid_add_inherit);
 
 /*
  * Add an ID or range to an ASIdentifierChoice.
@@ -483,7 +483,7 @@ X509v3_asid_add_id_or_range(ASIdentifiers *asid, int which, ASN1_INTEGER *min,
 	ASIdOrRange_free(aor);
 	return 0;
 }
-LCRYPTO_ALIAS(X509v3_asid_add_id_or_range)
+LCRYPTO_ALIAS(X509v3_asid_add_id_or_range);
 
 /*
  * Extract min and max values from an ASIdOrRange.
@@ -612,7 +612,7 @@ X509v3_asid_is_canonical(ASIdentifiers *asid)
 	    (ASIdentifierChoice_is_canonical(asid->asnum) &&
 	     ASIdentifierChoice_is_canonical(asid->rdi)));
 }
-LCRYPTO_ALIAS(X509v3_asid_is_canonical)
+LCRYPTO_ALIAS(X509v3_asid_is_canonical);
 
 /*
  * Whack an ASIdentifierChoice into canonical form.
@@ -780,7 +780,7 @@ X509v3_asid_canonize(ASIdentifiers *asid)
 
 	return ASIdentifierChoice_canonize(asid->rdi);
 }
-LCRYPTO_ALIAS(X509v3_asid_canonize)
+LCRYPTO_ALIAS(X509v3_asid_canonize);
 
 /*
  * v2i method for an ASIdentifier extension.
@@ -939,7 +939,7 @@ X509v3_asid_inherits(ASIdentifiers *asid)
 
 	return 0;
 }
-LCRYPTO_ALIAS(X509v3_asid_inherits)
+LCRYPTO_ALIAS(X509v3_asid_inherits);
 
 /*
  * Figure out whether parent contains child.
@@ -1013,7 +1013,7 @@ X509v3_asid_subset(ASIdentifiers *child, ASIdentifiers *parent)
 
 	return 1;
 }
-LCRYPTO_ALIAS(X509v3_asid_subset)
+LCRYPTO_ALIAS(X509v3_asid_subset);
 
 /*
  * Validation error handling via callback.
@@ -1181,7 +1181,7 @@ X509v3_asid_validate_path(X509_STORE_CTX *ctx)
 	}
 	return asid_validate_path_internal(ctx, ctx->chain, NULL);
 }
-LCRYPTO_ALIAS(X509v3_asid_validate_path)
+LCRYPTO_ALIAS(X509v3_asid_validate_path);
 
 /*
  * RFC 3779 3.3 path validation of an extension.
@@ -1199,6 +1199,6 @@ X509v3_asid_validate_resource_set(STACK_OF(X509) *chain, ASIdentifiers *ext,
 		return 0;
 	return asid_validate_path_internal(NULL, chain, ext);
 }
-LCRYPTO_ALIAS(X509v3_asid_validate_resource_set)
+LCRYPTO_ALIAS(X509v3_asid_validate_resource_set);
 
 #endif                          /* OPENSSL_NO_RFC3779 */
diff --git a/lib/libcrypto/x509/x509_att.c b/lib/libcrypto/x509/x509_att.c
index e769418fd3e..0c9d55f74f5 100644
--- a/lib/libcrypto/x509/x509_att.c
+++ b/lib/libcrypto/x509/x509_att.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_att.c,v 1.21 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_att.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -73,7 +73,7 @@ X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
 {
 	return sk_X509_ATTRIBUTE_num(x);
 }
-LCRYPTO_ALIAS(X509at_get_attr_count)
+LCRYPTO_ALIAS(X509at_get_attr_count);
 
 int
 X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos)
@@ -85,7 +85,7 @@ X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid, int lastpos)
 		return (-2);
 	return (X509at_get_attr_by_OBJ(x, obj, lastpos));
 }
-LCRYPTO_ALIAS(X509at_get_attr_by_NID)
+LCRYPTO_ALIAS(X509at_get_attr_by_NID);
 
 int
 X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
@@ -107,7 +107,7 @@ X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
 	}
 	return (-1);
 }
-LCRYPTO_ALIAS(X509at_get_attr_by_OBJ)
+LCRYPTO_ALIAS(X509at_get_attr_by_OBJ);
 
 X509_ATTRIBUTE *
 X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
@@ -117,7 +117,7 @@ X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
 	else
 		return sk_X509_ATTRIBUTE_value(x, loc);
 }
-LCRYPTO_ALIAS(X509at_get_attr)
+LCRYPTO_ALIAS(X509at_get_attr);
 
 X509_ATTRIBUTE *
 X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
@@ -129,7 +129,7 @@ X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
 	ret = sk_X509_ATTRIBUTE_delete(x, loc);
 	return (ret);
 }
-LCRYPTO_ALIAS(X509at_delete_attr)
+LCRYPTO_ALIAS(X509at_delete_attr);
 
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x, X509_ATTRIBUTE *attr)
@@ -165,7 +165,7 @@ err2:
 		sk_X509_ATTRIBUTE_free(sk);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509at_add1_attr)
+LCRYPTO_ALIAS(X509at_add1_attr);
 
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
@@ -181,7 +181,7 @@ X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE) **x, const ASN1_OBJECT *obj,
 	X509_ATTRIBUTE_free(attr);
 	return ret;
 }
-LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ)
+LCRYPTO_ALIAS(X509at_add1_attr_by_OBJ);
 
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
@@ -197,7 +197,7 @@ X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE) **x, int nid, int type,
 	X509_ATTRIBUTE_free(attr);
 	return ret;
 }
-LCRYPTO_ALIAS(X509at_add1_attr_by_NID)
+LCRYPTO_ALIAS(X509at_add1_attr_by_NID);
 
 STACK_OF(X509_ATTRIBUTE) *
 X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
@@ -213,7 +213,7 @@ X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE) **x, const char *attrname,
 	X509_ATTRIBUTE_free(attr);
 	return ret;
 }
-LCRYPTO_ALIAS(X509at_add1_attr_by_txt)
+LCRYPTO_ALIAS(X509at_add1_attr_by_txt);
 
 void *
 X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj,
@@ -232,7 +232,7 @@ X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x, const ASN1_OBJECT *obj,
 		return NULL;
 	return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
 }
-LCRYPTO_ALIAS(X509at_get0_data_by_OBJ)
+LCRYPTO_ALIAS(X509at_get0_data_by_OBJ);
 
 X509_ATTRIBUTE *
 X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
@@ -251,7 +251,7 @@ X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid, int atrtype,
 		ASN1_OBJECT_free(obj);
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_NID);
 
 X509_ATTRIBUTE *
 X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr, const ASN1_OBJECT *obj,
@@ -281,7 +281,7 @@ err:
 		X509_ATTRIBUTE_free(ret);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_OBJ);
 
 X509_ATTRIBUTE *
 X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
@@ -300,7 +300,7 @@ X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr, const char *atrname,
 	ASN1_OBJECT_free(obj);
 	return nattr;
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_create_by_txt);
 
 int
 X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
@@ -311,7 +311,7 @@ X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
 	attr->object = OBJ_dup(obj);
 	return attr->object != NULL;
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_object);
 
 int
 X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype, const void *data,
@@ -365,7 +365,7 @@ err:
 	X509error(ERR_R_MALLOC_FAILURE);
 	return 0;
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_set1_data);
 
 int
 X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
@@ -375,7 +375,7 @@ X509_ATTRIBUTE_count(const X509_ATTRIBUTE *attr)
 
 	return sk_ASN1_TYPE_num(attr->set);
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_count)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_count);
 
 ASN1_OBJECT *
 X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
@@ -384,7 +384,7 @@ X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
 		return (NULL);
 	return (attr->object);
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_object);
 
 void *
 X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
@@ -400,7 +400,7 @@ X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx, int atrtype, void *data)
 	}
 	return ttmp->value.ptr;
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_data);
 
 ASN1_TYPE *
 X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
@@ -410,4 +410,4 @@ X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
 
 	return sk_ASN1_TYPE_value(attr->set, idx);
 }
-LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type)
+LCRYPTO_ALIAS(X509_ATTRIBUTE_get0_type);
diff --git a/lib/libcrypto/x509/x509_bcons.c b/lib/libcrypto/x509/x509_bcons.c
index 8a9c1e419ac..a39ae0aae0b 100644
--- a/lib/libcrypto/x509/x509_bcons.c
+++ b/lib/libcrypto/x509/x509_bcons.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_bcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_bcons.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -121,28 +121,28 @@ d2i_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS **a, const unsigned char **in, long len)
 	return (BASIC_CONSTRAINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &BASIC_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS)
+LCRYPTO_ALIAS(d2i_BASIC_CONSTRAINTS);
 
 int
 i2d_BASIC_CONSTRAINTS(BASIC_CONSTRAINTS *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &BASIC_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS)
+LCRYPTO_ALIAS(i2d_BASIC_CONSTRAINTS);
 
 BASIC_CONSTRAINTS *
 BASIC_CONSTRAINTS_new(void)
 {
 	return (BASIC_CONSTRAINTS *)ASN1_item_new(&BASIC_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new)
+LCRYPTO_ALIAS(BASIC_CONSTRAINTS_new);
 
 void
 BASIC_CONSTRAINTS_free(BASIC_CONSTRAINTS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &BASIC_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free)
+LCRYPTO_ALIAS(BASIC_CONSTRAINTS_free);
 
 
 static STACK_OF(CONF_VALUE) *
diff --git a/lib/libcrypto/x509/x509_bitst.c b/lib/libcrypto/x509/x509_bitst.c
index bea089e31c8..cacbe8efe7c 100644
--- a/lib/libcrypto/x509/x509_bitst.c
+++ b/lib/libcrypto/x509/x509_bitst.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_bitst.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_bitst.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -148,7 +148,7 @@ i2v_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, ASN1_BIT_STRING *bits,
 
 	return NULL;
 }
-LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING)
+LCRYPTO_ALIAS(i2v_ASN1_BIT_STRING);
 
 ASN1_BIT_STRING *
 v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -186,4 +186,4 @@ v2i_ASN1_BIT_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
 	}
 	return bs;
 }
-LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING)
+LCRYPTO_ALIAS(v2i_ASN1_BIT_STRING);
diff --git a/lib/libcrypto/x509/x509_cmp.c b/lib/libcrypto/x509/x509_cmp.c
index b76c9ea6601..3ee4fd4a5da 100644
--- a/lib/libcrypto/x509/x509_cmp.c
+++ b/lib/libcrypto/x509/x509_cmp.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_cmp.c,v 1.41 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_cmp.c,v 1.42 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -84,7 +84,7 @@ X509_issuer_and_serial_cmp(const X509 *a, const X509 *b)
 		return (i);
 	return (X509_NAME_cmp(ai->issuer, bi->issuer));
 }
-LCRYPTO_ALIAS(X509_issuer_and_serial_cmp)
+LCRYPTO_ALIAS(X509_issuer_and_serial_cmp);
 
 #ifndef OPENSSL_NO_MD5
 unsigned long
@@ -120,7 +120,7 @@ err:
 	free(f);
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_issuer_and_serial_hash)
+LCRYPTO_ALIAS(X509_issuer_and_serial_hash);
 #endif
 
 int
@@ -128,21 +128,21 @@ X509_issuer_name_cmp(const X509 *a, const X509 *b)
 {
 	return (X509_NAME_cmp(a->cert_info->issuer, b->cert_info->issuer));
 }
-LCRYPTO_ALIAS(X509_issuer_name_cmp)
+LCRYPTO_ALIAS(X509_issuer_name_cmp);
 
 int
 X509_subject_name_cmp(const X509 *a, const X509 *b)
 {
 	return (X509_NAME_cmp(a->cert_info->subject, b->cert_info->subject));
 }
-LCRYPTO_ALIAS(X509_subject_name_cmp)
+LCRYPTO_ALIAS(X509_subject_name_cmp);
 
 int
 X509_CRL_cmp(const X509_CRL *a, const X509_CRL *b)
 {
 	return (X509_NAME_cmp(a->crl->issuer, b->crl->issuer));
 }
-LCRYPTO_ALIAS(X509_CRL_cmp)
+LCRYPTO_ALIAS(X509_CRL_cmp);
 
 #ifndef OPENSSL_NO_SHA
 int
@@ -150,7 +150,7 @@ X509_CRL_match(const X509_CRL *a, const X509_CRL *b)
 {
 	return memcmp(a->hash, b->hash, X509_CRL_HASH_LEN);
 }
-LCRYPTO_ALIAS(X509_CRL_match)
+LCRYPTO_ALIAS(X509_CRL_match);
 #endif
 
 X509_NAME *
@@ -158,14 +158,14 @@ X509_get_issuer_name(const X509 *a)
 {
 	return (a->cert_info->issuer);
 }
-LCRYPTO_ALIAS(X509_get_issuer_name)
+LCRYPTO_ALIAS(X509_get_issuer_name);
 
 unsigned long
 X509_issuer_name_hash(X509 *x)
 {
 	return (X509_NAME_hash(x->cert_info->issuer));
 }
-LCRYPTO_ALIAS(X509_issuer_name_hash)
+LCRYPTO_ALIAS(X509_issuer_name_hash);
 
 #ifndef OPENSSL_NO_MD5
 unsigned long
@@ -173,7 +173,7 @@ X509_issuer_name_hash_old(X509 *x)
 {
 	return (X509_NAME_hash_old(x->cert_info->issuer));
 }
-LCRYPTO_ALIAS(X509_issuer_name_hash_old)
+LCRYPTO_ALIAS(X509_issuer_name_hash_old);
 #endif
 
 X509_NAME *
@@ -181,28 +181,28 @@ X509_get_subject_name(const X509 *a)
 {
 	return (a->cert_info->subject);
 }
-LCRYPTO_ALIAS(X509_get_subject_name)
+LCRYPTO_ALIAS(X509_get_subject_name);
 
 ASN1_INTEGER *
 X509_get_serialNumber(X509 *a)
 {
 	return (a->cert_info->serialNumber);
 }
-LCRYPTO_ALIAS(X509_get_serialNumber)
+LCRYPTO_ALIAS(X509_get_serialNumber);
 
 const ASN1_INTEGER *
 X509_get0_serialNumber(const X509 *a)
 {
 	return (a->cert_info->serialNumber);
 }
-LCRYPTO_ALIAS(X509_get0_serialNumber)
+LCRYPTO_ALIAS(X509_get0_serialNumber);
 
 unsigned long
 X509_subject_name_hash(X509 *x)
 {
 	return (X509_NAME_hash(x->cert_info->subject));
 }
-LCRYPTO_ALIAS(X509_subject_name_hash)
+LCRYPTO_ALIAS(X509_subject_name_hash);
 
 #ifndef OPENSSL_NO_MD5
 unsigned long
@@ -210,7 +210,7 @@ X509_subject_name_hash_old(X509 *x)
 {
 	return (X509_NAME_hash_old(x->cert_info->subject));
 }
-LCRYPTO_ALIAS(X509_subject_name_hash_old)
+LCRYPTO_ALIAS(X509_subject_name_hash_old);
 #endif
 
 #ifndef OPENSSL_NO_SHA
@@ -232,7 +232,7 @@ X509_cmp(const X509 *a, const X509 *b)
 
 	return memcmp(a->hash, b->hash, X509_CERT_HASH_LEN);
 }
-LCRYPTO_ALIAS(X509_cmp)
+LCRYPTO_ALIAS(X509_cmp);
 #endif
 
 int
@@ -256,7 +256,7 @@ X509_NAME_cmp(const X509_NAME *a, const X509_NAME *b)
 		return ret;
 	return memcmp(a->canon_enc, b->canon_enc, a->canon_enclen);
 }
-LCRYPTO_ALIAS(X509_NAME_cmp)
+LCRYPTO_ALIAS(X509_NAME_cmp);
 
 unsigned long
 X509_NAME_hash(X509_NAME *x)
@@ -275,7 +275,7 @@ X509_NAME_hash(X509_NAME *x)
 	    0xffffffffL;
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_NAME_hash)
+LCRYPTO_ALIAS(X509_NAME_hash);
 
 
 #ifndef OPENSSL_NO_MD5
@@ -304,7 +304,7 @@ X509_NAME_hash_old(X509_NAME *x)
 
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_NAME_hash_old)
+LCRYPTO_ALIAS(X509_NAME_hash_old);
 #endif
 
 /* Search a stack of X509 for a match */
@@ -330,7 +330,7 @@ X509_find_by_issuer_and_serial(STACK_OF(X509) *sk, X509_NAME *name,
 	}
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_find_by_issuer_and_serial)
+LCRYPTO_ALIAS(X509_find_by_issuer_and_serial);
 
 X509 *
 X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name)
@@ -345,7 +345,7 @@ X509_find_by_subject(STACK_OF(X509) *sk, X509_NAME *name)
 	}
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_find_by_subject)
+LCRYPTO_ALIAS(X509_find_by_subject);
 
 EVP_PKEY *
 X509_get_pubkey(X509 *x)
@@ -354,7 +354,7 @@ X509_get_pubkey(X509 *x)
 		return (NULL);
 	return (X509_PUBKEY_get(x->cert_info->key));
 }
-LCRYPTO_ALIAS(X509_get_pubkey)
+LCRYPTO_ALIAS(X509_get_pubkey);
 
 EVP_PKEY *
 X509_get0_pubkey(const X509 *x)
@@ -363,7 +363,7 @@ X509_get0_pubkey(const X509 *x)
 		return (NULL);
 	return (X509_PUBKEY_get0(x->cert_info->key));
 }
-LCRYPTO_ALIAS(X509_get0_pubkey)
+LCRYPTO_ALIAS(X509_get0_pubkey);
 
 ASN1_BIT_STRING *
 X509_get0_pubkey_bitstr(const X509 *x)
@@ -372,7 +372,7 @@ X509_get0_pubkey_bitstr(const X509 *x)
 		return NULL;
 	return x->cert_info->key->public_key;
 }
-LCRYPTO_ALIAS(X509_get0_pubkey_bitstr)
+LCRYPTO_ALIAS(X509_get0_pubkey_bitstr);
 
 int
 X509_check_private_key(const X509 *x, const EVP_PKEY *k)
@@ -403,7 +403,7 @@ X509_check_private_key(const X509 *x, const EVP_PKEY *k)
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_check_private_key)
+LCRYPTO_ALIAS(X509_check_private_key);
 
 /*
  * Not strictly speaking an "up_ref" as a STACK doesn't have a reference
@@ -422,4 +422,4 @@ X509_chain_up_ref(STACK_OF(X509) *chain)
 
 	return ret;
 }
-LCRYPTO_ALIAS(X509_chain_up_ref)
+LCRYPTO_ALIAS(X509_chain_up_ref);
diff --git a/lib/libcrypto/x509/x509_conf.c b/lib/libcrypto/x509/x509_conf.c
index 2b3274d04d5..189bf644054 100644
--- a/lib/libcrypto/x509/x509_conf.c
+++ b/lib/libcrypto/x509/x509_conf.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_conf.c,v 1.4 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_conf.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -104,7 +104,7 @@ X509V3_EXT_nconf(CONF *conf, X509V3_CTX *ctx, const char *name,
 	}
 	return ret;
 }
-LCRYPTO_ALIAS(X509V3_EXT_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_nconf);
 
 /* CONF *conf:  Config file    */
 /* char *value:  Value    */
@@ -121,7 +121,7 @@ X509V3_EXT_nconf_nid(CONF *conf, X509V3_CTX *ctx, int ext_nid,
 		    value, crit, ext_type, ctx);
 	return do_ext_nconf(conf, ctx, ext_nid, crit, value);
 }
-LCRYPTO_ALIAS(X509V3_EXT_nconf_nid)
+LCRYPTO_ALIAS(X509V3_EXT_nconf_nid);
 
 /* CONF *conf:  Config file    */
 /* char *value:  Value    */
@@ -240,7 +240,7 @@ X509V3_EXT_i2d(int ext_nid, int crit, void *ext_struc)
 	}
 	return do_ext_i2d(method, ext_nid, crit, ext_struc);
 }
-LCRYPTO_ALIAS(X509V3_EXT_i2d)
+LCRYPTO_ALIAS(X509V3_EXT_i2d);
 
 /* Check the extension string for critical flag */
 static int
@@ -367,7 +367,7 @@ X509V3_EXT_add_nconf_sk(CONF *conf, X509V3_CTX *ctx, const char *section,
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk)
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf_sk);
 
 /* Convenience functions to add extensions to a certificate, CRL and request */
 
@@ -381,7 +381,7 @@ X509V3_EXT_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
 		sk = &cert->cert_info->extensions;
 	return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 }
-LCRYPTO_ALIAS(X509V3_EXT_add_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_add_nconf);
 
 /* Same as above but for a CRL */
 
@@ -395,7 +395,7 @@ X509V3_EXT_CRL_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
 		sk = &crl->crl->extensions;
 	return X509V3_EXT_add_nconf_sk(conf, ctx, section, sk);
 }
-LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_CRL_add_nconf);
 
 /* Add extensions to certificate request */
 
@@ -415,7 +415,7 @@ X509V3_EXT_REQ_add_nconf(CONF *conf, X509V3_CTX *ctx, const char *section,
 	sk_X509_EXTENSION_pop_free(extlist, X509_EXTENSION_free);
 	return i;
 }
-LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf)
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_nconf);
 
 /* Config database functions */
 
@@ -428,7 +428,7 @@ X509V3_get_string(X509V3_CTX *ctx, const char *name, const char *section)
 	}
 	return ctx->db_meth->get_string(ctx->db, name, section);
 }
-LCRYPTO_ALIAS(X509V3_get_string)
+LCRYPTO_ALIAS(X509V3_get_string);
 
 STACK_OF(CONF_VALUE) *
 X509V3_get_section(X509V3_CTX *ctx, const char *section)
@@ -439,7 +439,7 @@ X509V3_get_section(X509V3_CTX *ctx, const char *section)
 	}
 	return ctx->db_meth->get_section(ctx->db, section);
 }
-LCRYPTO_ALIAS(X509V3_get_section)
+LCRYPTO_ALIAS(X509V3_get_section);
 
 void
 X509V3_string_free(X509V3_CTX *ctx, char *str)
@@ -449,7 +449,7 @@ X509V3_string_free(X509V3_CTX *ctx, char *str)
 	if (ctx->db_meth->free_string)
 		ctx->db_meth->free_string(ctx->db, str);
 }
-LCRYPTO_ALIAS(X509V3_string_free)
+LCRYPTO_ALIAS(X509V3_string_free);
 
 void
 X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section)
@@ -459,7 +459,7 @@ X509V3_section_free(X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *section)
 	if (ctx->db_meth->free_section)
 		ctx->db_meth->free_section(ctx->db, section);
 }
-LCRYPTO_ALIAS(X509V3_section_free)
+LCRYPTO_ALIAS(X509V3_section_free);
 
 static char *
 nconf_get_string(void *db, const char *section, const char *value)
@@ -486,7 +486,7 @@ X509V3_set_nconf(X509V3_CTX *ctx, CONF *conf)
 	ctx->db_meth = &nconf_method;
 	ctx->db = conf;
 }
-LCRYPTO_ALIAS(X509V3_set_nconf)
+LCRYPTO_ALIAS(X509V3_set_nconf);
 
 void
 X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
@@ -498,7 +498,7 @@ X509V3_set_ctx(X509V3_CTX *ctx, X509 *issuer, X509 *subj, X509_REQ *req,
 	ctx->subject_req = req;
 	ctx->flags = flags;
 }
-LCRYPTO_ALIAS(X509V3_set_ctx)
+LCRYPTO_ALIAS(X509V3_set_ctx);
 
 /* Old conf compatibility functions */
 
@@ -511,7 +511,7 @@ X509V3_EXT_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, const char *name,
 	CONF_set_nconf(&ctmp, conf);
 	return X509V3_EXT_nconf(&ctmp, ctx, name, value);
 }
-LCRYPTO_ALIAS(X509V3_EXT_conf)
+LCRYPTO_ALIAS(X509V3_EXT_conf);
 
 /* LHASH *conf:  Config file    */
 /* char *value:  Value    */
@@ -524,7 +524,7 @@ X509V3_EXT_conf_nid(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx, int ext_nid,
 	CONF_set_nconf(&ctmp, conf);
 	return X509V3_EXT_nconf_nid(&ctmp, ctx, ext_nid, value);
 }
-LCRYPTO_ALIAS(X509V3_EXT_conf_nid)
+LCRYPTO_ALIAS(X509V3_EXT_conf_nid);
 
 static char *
 conf_lhash_get_string(void *db, const char *section, const char *value)
@@ -551,7 +551,7 @@ X509V3_set_conf_lhash(X509V3_CTX *ctx, LHASH_OF(CONF_VALUE) *lhash)
 	ctx->db_meth = &conf_lhash_method;
 	ctx->db = lhash;
 }
-LCRYPTO_ALIAS(X509V3_set_conf_lhash)
+LCRYPTO_ALIAS(X509V3_set_conf_lhash);
 
 int
 X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
@@ -562,7 +562,7 @@ X509V3_EXT_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 	CONF_set_nconf(&ctmp, conf);
 	return X509V3_EXT_add_nconf(&ctmp, ctx, section, cert);
 }
-LCRYPTO_ALIAS(X509V3_EXT_add_conf)
+LCRYPTO_ALIAS(X509V3_EXT_add_conf);
 
 /* Same as above but for a CRL */
 
@@ -575,7 +575,7 @@ X509V3_EXT_CRL_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 	CONF_set_nconf(&ctmp, conf);
 	return X509V3_EXT_CRL_add_nconf(&ctmp, ctx, section, crl);
 }
-LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf)
+LCRYPTO_ALIAS(X509V3_EXT_CRL_add_conf);
 
 /* Add extensions to certificate request */
 
@@ -588,4 +588,4 @@ X509V3_EXT_REQ_add_conf(LHASH_OF(CONF_VALUE) *conf, X509V3_CTX *ctx,
 	CONF_set_nconf(&ctmp, conf);
 	return X509V3_EXT_REQ_add_nconf(&ctmp, ctx, section, req);
 }
-LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf)
+LCRYPTO_ALIAS(X509V3_EXT_REQ_add_conf);
diff --git a/lib/libcrypto/x509/x509_cpols.c b/lib/libcrypto/x509/x509_cpols.c
index 12e4a55c473..3f106c691de 100644
--- a/lib/libcrypto/x509/x509_cpols.c
+++ b/lib/libcrypto/x509/x509_cpols.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_cpols.c,v 1.6 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_cpols.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -125,28 +125,28 @@ d2i_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES **a, const unsigned char **in, long
 	return (CERTIFICATEPOLICIES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &CERTIFICATEPOLICIES_it);
 }
-LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES)
+LCRYPTO_ALIAS(d2i_CERTIFICATEPOLICIES);
 
 int
 i2d_CERTIFICATEPOLICIES(CERTIFICATEPOLICIES *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &CERTIFICATEPOLICIES_it);
 }
-LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES)
+LCRYPTO_ALIAS(i2d_CERTIFICATEPOLICIES);
 
 CERTIFICATEPOLICIES *
 CERTIFICATEPOLICIES_new(void)
 {
 	return (CERTIFICATEPOLICIES *)ASN1_item_new(&CERTIFICATEPOLICIES_it);
 }
-LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new)
+LCRYPTO_ALIAS(CERTIFICATEPOLICIES_new);
 
 void
 CERTIFICATEPOLICIES_free(CERTIFICATEPOLICIES *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &CERTIFICATEPOLICIES_it);
 }
-LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free)
+LCRYPTO_ALIAS(CERTIFICATEPOLICIES_free);
 
 static const ASN1_TEMPLATE POLICYINFO_seq_tt[] = {
 	{
@@ -182,28 +182,28 @@ d2i_POLICYINFO(POLICYINFO **a, const unsigned char **in, long len)
 	return (POLICYINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &POLICYINFO_it);
 }
-LCRYPTO_ALIAS(d2i_POLICYINFO)
+LCRYPTO_ALIAS(d2i_POLICYINFO);
 
 int
 i2d_POLICYINFO(POLICYINFO *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYINFO_it);
 }
-LCRYPTO_ALIAS(i2d_POLICYINFO)
+LCRYPTO_ALIAS(i2d_POLICYINFO);
 
 POLICYINFO *
 POLICYINFO_new(void)
 {
 	return (POLICYINFO *)ASN1_item_new(&POLICYINFO_it);
 }
-LCRYPTO_ALIAS(POLICYINFO_new)
+LCRYPTO_ALIAS(POLICYINFO_new);
 
 void
 POLICYINFO_free(POLICYINFO *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &POLICYINFO_it);
 }
-LCRYPTO_ALIAS(POLICYINFO_free)
+LCRYPTO_ALIAS(POLICYINFO_free);
 
 static const ASN1_TEMPLATE policydefault_tt = {
 	.flags = 0,
@@ -281,28 +281,28 @@ d2i_POLICYQUALINFO(POLICYQUALINFO **a, const unsigned char **in, long len)
 	return (POLICYQUALINFO *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &POLICYQUALINFO_it);
 }
-LCRYPTO_ALIAS(d2i_POLICYQUALINFO)
+LCRYPTO_ALIAS(d2i_POLICYQUALINFO);
 
 int
 i2d_POLICYQUALINFO(POLICYQUALINFO *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &POLICYQUALINFO_it);
 }
-LCRYPTO_ALIAS(i2d_POLICYQUALINFO)
+LCRYPTO_ALIAS(i2d_POLICYQUALINFO);
 
 POLICYQUALINFO *
 POLICYQUALINFO_new(void)
 {
 	return (POLICYQUALINFO *)ASN1_item_new(&POLICYQUALINFO_it);
 }
-LCRYPTO_ALIAS(POLICYQUALINFO_new)
+LCRYPTO_ALIAS(POLICYQUALINFO_new);
 
 void
 POLICYQUALINFO_free(POLICYQUALINFO *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &POLICYQUALINFO_it);
 }
-LCRYPTO_ALIAS(POLICYQUALINFO_free)
+LCRYPTO_ALIAS(POLICYQUALINFO_free);
 
 static const ASN1_TEMPLATE USERNOTICE_seq_tt[] = {
 	{
@@ -338,28 +338,28 @@ d2i_USERNOTICE(USERNOTICE **a, const unsigned char **in, long len)
 	return (USERNOTICE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &USERNOTICE_it);
 }
-LCRYPTO_ALIAS(d2i_USERNOTICE)
+LCRYPTO_ALIAS(d2i_USERNOTICE);
 
 int
 i2d_USERNOTICE(USERNOTICE *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &USERNOTICE_it);
 }
-LCRYPTO_ALIAS(i2d_USERNOTICE)
+LCRYPTO_ALIAS(i2d_USERNOTICE);
 
 USERNOTICE *
 USERNOTICE_new(void)
 {
 	return (USERNOTICE *)ASN1_item_new(&USERNOTICE_it);
 }
-LCRYPTO_ALIAS(USERNOTICE_new)
+LCRYPTO_ALIAS(USERNOTICE_new);
 
 void
 USERNOTICE_free(USERNOTICE *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &USERNOTICE_it);
 }
-LCRYPTO_ALIAS(USERNOTICE_free)
+LCRYPTO_ALIAS(USERNOTICE_free);
 
 static const ASN1_TEMPLATE NOTICEREF_seq_tt[] = {
 	{
@@ -395,28 +395,28 @@ d2i_NOTICEREF(NOTICEREF **a, const unsigned char **in, long len)
 	return (NOTICEREF *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &NOTICEREF_it);
 }
-LCRYPTO_ALIAS(d2i_NOTICEREF)
+LCRYPTO_ALIAS(d2i_NOTICEREF);
 
 int
 i2d_NOTICEREF(NOTICEREF *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &NOTICEREF_it);
 }
-LCRYPTO_ALIAS(i2d_NOTICEREF)
+LCRYPTO_ALIAS(i2d_NOTICEREF);
 
 NOTICEREF *
 NOTICEREF_new(void)
 {
 	return (NOTICEREF *)ASN1_item_new(&NOTICEREF_it);
 }
-LCRYPTO_ALIAS(NOTICEREF_new)
+LCRYPTO_ALIAS(NOTICEREF_new);
 
 void
 NOTICEREF_free(NOTICEREF *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &NOTICEREF_it);
 }
-LCRYPTO_ALIAS(NOTICEREF_free)
+LCRYPTO_ALIAS(NOTICEREF_free);
 
 static STACK_OF(POLICYINFO) *
 r2i_certpol(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *value)
@@ -782,4 +782,4 @@ X509_POLICY_NODE_print(BIO *out, X509_POLICY_NODE *node, int indent)
 	else
 		BIO_printf(out, "%*sNo Qualifiers\n", indent + 2, "");
 }
-LCRYPTO_ALIAS(X509_POLICY_NODE_print)
+LCRYPTO_ALIAS(X509_POLICY_NODE_print);
diff --git a/lib/libcrypto/x509/x509_crld.c b/lib/libcrypto/x509/x509_crld.c
index ef9c82bb3f2..7887ccd644e 100644
--- a/lib/libcrypto/x509/x509_crld.c
+++ b/lib/libcrypto/x509/x509_crld.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_crld.c,v 1.4 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_crld.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -426,28 +426,28 @@ d2i_DIST_POINT_NAME(DIST_POINT_NAME **a, const unsigned char **in, long len)
 	return (DIST_POINT_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &DIST_POINT_NAME_it);
 }
-LCRYPTO_ALIAS(d2i_DIST_POINT_NAME)
+LCRYPTO_ALIAS(d2i_DIST_POINT_NAME);
 
 int
 i2d_DIST_POINT_NAME(DIST_POINT_NAME *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_NAME_it);
 }
-LCRYPTO_ALIAS(i2d_DIST_POINT_NAME)
+LCRYPTO_ALIAS(i2d_DIST_POINT_NAME);
 
 DIST_POINT_NAME *
 DIST_POINT_NAME_new(void)
 {
 	return (DIST_POINT_NAME *)ASN1_item_new(&DIST_POINT_NAME_it);
 }
-LCRYPTO_ALIAS(DIST_POINT_NAME_new)
+LCRYPTO_ALIAS(DIST_POINT_NAME_new);
 
 void
 DIST_POINT_NAME_free(DIST_POINT_NAME *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_NAME_it);
 }
-LCRYPTO_ALIAS(DIST_POINT_NAME_free)
+LCRYPTO_ALIAS(DIST_POINT_NAME_free);
 
 static const ASN1_TEMPLATE DIST_POINT_seq_tt[] = {
 	{
@@ -490,28 +490,28 @@ d2i_DIST_POINT(DIST_POINT **a, const unsigned char **in, long len)
 	return (DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &DIST_POINT_it);
 }
-LCRYPTO_ALIAS(d2i_DIST_POINT)
+LCRYPTO_ALIAS(d2i_DIST_POINT);
 
 int
 i2d_DIST_POINT(DIST_POINT *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &DIST_POINT_it);
 }
-LCRYPTO_ALIAS(i2d_DIST_POINT)
+LCRYPTO_ALIAS(i2d_DIST_POINT);
 
 DIST_POINT *
 DIST_POINT_new(void)
 {
 	return (DIST_POINT *)ASN1_item_new(&DIST_POINT_it);
 }
-LCRYPTO_ALIAS(DIST_POINT_new)
+LCRYPTO_ALIAS(DIST_POINT_new);
 
 void
 DIST_POINT_free(DIST_POINT *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &DIST_POINT_it);
 }
-LCRYPTO_ALIAS(DIST_POINT_free)
+LCRYPTO_ALIAS(DIST_POINT_free);
 
 static const ASN1_TEMPLATE CRL_DIST_POINTS_item_tt = {
 	.flags = ASN1_TFLG_SEQUENCE_OF,
@@ -538,28 +538,28 @@ d2i_CRL_DIST_POINTS(CRL_DIST_POINTS **a, const unsigned char **in, long len)
 	return (CRL_DIST_POINTS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &CRL_DIST_POINTS_it);
 }
-LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS)
+LCRYPTO_ALIAS(d2i_CRL_DIST_POINTS);
 
 int
 i2d_CRL_DIST_POINTS(CRL_DIST_POINTS *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &CRL_DIST_POINTS_it);
 }
-LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS)
+LCRYPTO_ALIAS(i2d_CRL_DIST_POINTS);
 
 CRL_DIST_POINTS *
 CRL_DIST_POINTS_new(void)
 {
 	return (CRL_DIST_POINTS *)ASN1_item_new(&CRL_DIST_POINTS_it);
 }
-LCRYPTO_ALIAS(CRL_DIST_POINTS_new)
+LCRYPTO_ALIAS(CRL_DIST_POINTS_new);
 
 void
 CRL_DIST_POINTS_free(CRL_DIST_POINTS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &CRL_DIST_POINTS_it);
 }
-LCRYPTO_ALIAS(CRL_DIST_POINTS_free)
+LCRYPTO_ALIAS(CRL_DIST_POINTS_free);
 
 static const ASN1_TEMPLATE ISSUING_DIST_POINT_seq_tt[] = {
 	{
@@ -623,28 +623,28 @@ d2i_ISSUING_DIST_POINT(ISSUING_DIST_POINT **a, const unsigned char **in, long le
 	return (ISSUING_DIST_POINT *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ISSUING_DIST_POINT_it);
 }
-LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT)
+LCRYPTO_ALIAS(d2i_ISSUING_DIST_POINT);
 
 int
 i2d_ISSUING_DIST_POINT(ISSUING_DIST_POINT *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ISSUING_DIST_POINT_it);
 }
-LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT)
+LCRYPTO_ALIAS(i2d_ISSUING_DIST_POINT);
 
 ISSUING_DIST_POINT *
 ISSUING_DIST_POINT_new(void)
 {
 	return (ISSUING_DIST_POINT *)ASN1_item_new(&ISSUING_DIST_POINT_it);
 }
-LCRYPTO_ALIAS(ISSUING_DIST_POINT_new)
+LCRYPTO_ALIAS(ISSUING_DIST_POINT_new);
 
 void
 ISSUING_DIST_POINT_free(ISSUING_DIST_POINT *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ISSUING_DIST_POINT_it);
 }
-LCRYPTO_ALIAS(ISSUING_DIST_POINT_free)
+LCRYPTO_ALIAS(ISSUING_DIST_POINT_free);
 
 static int i2r_idp(const X509V3_EXT_METHOD *method, void *pidp, BIO *out,
     int indent);
@@ -825,4 +825,4 @@ DIST_POINT_set_dpname(DIST_POINT_NAME *dpn, X509_NAME *iname)
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(DIST_POINT_set_dpname)
+LCRYPTO_ALIAS(DIST_POINT_set_dpname);
diff --git a/lib/libcrypto/x509/x509_d2.c b/lib/libcrypto/x509/x509_d2.c
index 522062a694b..bf358ec2997 100644
--- a/lib/libcrypto/x509/x509_d2.c
+++ b/lib/libcrypto/x509/x509_d2.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_d2.c,v 1.11 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_d2.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -83,7 +83,7 @@ X509_STORE_set_default_paths(X509_STORE *ctx)
 
 	return (1);
 }
-LCRYPTO_ALIAS(X509_STORE_set_default_paths)
+LCRYPTO_ALIAS(X509_STORE_set_default_paths);
 
 int
 X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path)
@@ -108,7 +108,7 @@ X509_STORE_load_locations(X509_STORE *ctx, const char *file, const char *path)
 		return (0);
 	return (1);
 }
-LCRYPTO_ALIAS(X509_STORE_load_locations)
+LCRYPTO_ALIAS(X509_STORE_load_locations);
 
 int
 X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len)
@@ -128,4 +128,4 @@ X509_STORE_load_mem(X509_STORE *ctx, void *buf, int len)
 
 	return (1);
 }
-LCRYPTO_ALIAS(X509_STORE_load_mem)
+LCRYPTO_ALIAS(X509_STORE_load_mem);
diff --git a/lib/libcrypto/x509/x509_def.c b/lib/libcrypto/x509/x509_def.c
index 0d8900a5266..f85781afdd8 100644
--- a/lib/libcrypto/x509/x509_def.c
+++ b/lib/libcrypto/x509/x509_def.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_def.c,v 1.6 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_def.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -66,39 +66,39 @@ X509_get_default_private_dir(void)
 {
 	return (X509_PRIVATE_DIR);
 }
-LCRYPTO_ALIAS(X509_get_default_private_dir)
+LCRYPTO_ALIAS(X509_get_default_private_dir);
 
 const char *
 X509_get_default_cert_area(void)
 {
 	return (X509_CERT_AREA);
 }
-LCRYPTO_ALIAS(X509_get_default_cert_area)
+LCRYPTO_ALIAS(X509_get_default_cert_area);
 
 const char *
 X509_get_default_cert_dir(void)
 {
 	return (X509_CERT_DIR);
 }
-LCRYPTO_ALIAS(X509_get_default_cert_dir)
+LCRYPTO_ALIAS(X509_get_default_cert_dir);
 
 const char *
 X509_get_default_cert_file(void)
 {
 	return (X509_CERT_FILE);
 }
-LCRYPTO_ALIAS(X509_get_default_cert_file)
+LCRYPTO_ALIAS(X509_get_default_cert_file);
 
 const char *
 X509_get_default_cert_dir_env(void)
 {
 	return (X509_CERT_DIR_EVP);
 }
-LCRYPTO_ALIAS(X509_get_default_cert_dir_env)
+LCRYPTO_ALIAS(X509_get_default_cert_dir_env);
 
 const char *
 X509_get_default_cert_file_env(void)
 {
 	return (X509_CERT_FILE_EVP);
 }
-LCRYPTO_ALIAS(X509_get_default_cert_file_env)
+LCRYPTO_ALIAS(X509_get_default_cert_file_env);
diff --git a/lib/libcrypto/x509/x509_enum.c b/lib/libcrypto/x509/x509_enum.c
index f0ab60a4b01..432239e0fe7 100644
--- a/lib/libcrypto/x509/x509_enum.c
+++ b/lib/libcrypto/x509/x509_enum.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_enum.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_enum.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -105,4 +105,4 @@ i2s_ASN1_ENUMERATED_TABLE(X509V3_EXT_METHOD *method, const ASN1_ENUMERATED *e)
 	}
 	return i2s_ASN1_ENUMERATED(method, e);
 }
-LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE)
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED_TABLE);
diff --git a/lib/libcrypto/x509/x509_err.c b/lib/libcrypto/x509/x509_err.c
index c83655046aa..272d2894d86 100644
--- a/lib/libcrypto/x509/x509_err.c
+++ b/lib/libcrypto/x509/x509_err.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_err.c,v 1.18 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_err.c,v 1.19 2023/02/16 08:38:17 tb Exp $ */
 /* ====================================================================
  * Copyright (c) 1999-2006 The OpenSSL Project.  All rights reserved.
  *
@@ -191,7 +191,7 @@ ERR_load_X509_strings(void)
 	}
 #endif
 }
-LCRYPTO_ALIAS(ERR_load_X509_strings)
+LCRYPTO_ALIAS(ERR_load_X509_strings);
 
 
 void
@@ -204,4 +204,4 @@ ERR_load_X509V3_strings(void)
 	}
 #endif
 }
-LCRYPTO_ALIAS(ERR_load_X509V3_strings)
+LCRYPTO_ALIAS(ERR_load_X509V3_strings);
diff --git a/lib/libcrypto/x509/x509_ext.c b/lib/libcrypto/x509/x509_ext.c
index c173b7c687c..ce316d25bd5 100644
--- a/lib/libcrypto/x509/x509_ext.c
+++ b/lib/libcrypto/x509/x509_ext.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_ext.c,v 1.15 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_ext.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -72,49 +72,49 @@ X509_CRL_get_ext_count(const X509_CRL *x)
 {
 	return (X509v3_get_ext_count(x->crl->extensions));
 }
-LCRYPTO_ALIAS(X509_CRL_get_ext_count)
+LCRYPTO_ALIAS(X509_CRL_get_ext_count);
 
 int
 X509_CRL_get_ext_by_NID(const X509_CRL *x, int nid, int lastpos)
 {
 	return (X509v3_get_ext_by_NID(x->crl->extensions, nid, lastpos));
 }
-LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID)
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_NID);
 
 int
 X509_CRL_get_ext_by_OBJ(const X509_CRL *x, const ASN1_OBJECT *obj, int lastpos)
 {
 	return (X509v3_get_ext_by_OBJ(x->crl->extensions, obj, lastpos));
 }
-LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_OBJ);
 
 int
 X509_CRL_get_ext_by_critical(const X509_CRL *x, int crit, int lastpos)
 {
 	return (X509v3_get_ext_by_critical(x->crl->extensions, crit, lastpos));
 }
-LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical)
+LCRYPTO_ALIAS(X509_CRL_get_ext_by_critical);
 
 X509_EXTENSION *
 X509_CRL_get_ext(const X509_CRL *x, int loc)
 {
 	return (X509v3_get_ext(x->crl->extensions, loc));
 }
-LCRYPTO_ALIAS(X509_CRL_get_ext)
+LCRYPTO_ALIAS(X509_CRL_get_ext);
 
 X509_EXTENSION *
 X509_CRL_delete_ext(X509_CRL *x, int loc)
 {
 	return (X509v3_delete_ext(x->crl->extensions, loc));
 }
-LCRYPTO_ALIAS(X509_CRL_delete_ext)
+LCRYPTO_ALIAS(X509_CRL_delete_ext);
 
 void *
 X509_CRL_get_ext_d2i(const X509_CRL *x, int nid, int *crit, int *idx)
 {
 	return X509V3_get_d2i(x->crl->extensions, nid, crit, idx);
 }
-LCRYPTO_ALIAS(X509_CRL_get_ext_d2i)
+LCRYPTO_ALIAS(X509_CRL_get_ext_d2i);
 
 int
 X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
@@ -122,35 +122,35 @@ X509_CRL_add1_ext_i2d(X509_CRL *x, int nid, void *value, int crit,
 {
 	return X509V3_add1_i2d(&x->crl->extensions, nid, value, crit, flags);
 }
-LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d)
+LCRYPTO_ALIAS(X509_CRL_add1_ext_i2d);
 
 int
 X509_CRL_add_ext(X509_CRL *x, X509_EXTENSION *ex, int loc)
 {
 	return (X509v3_add_ext(&(x->crl->extensions), ex, loc) != NULL);
 }
-LCRYPTO_ALIAS(X509_CRL_add_ext)
+LCRYPTO_ALIAS(X509_CRL_add_ext);
 
 int
 X509_get_ext_count(const X509 *x)
 {
 	return (X509v3_get_ext_count(x->cert_info->extensions));
 }
-LCRYPTO_ALIAS(X509_get_ext_count)
+LCRYPTO_ALIAS(X509_get_ext_count);
 
 int
 X509_get_ext_by_NID(const X509 *x, int nid, int lastpos)
 {
 	return (X509v3_get_ext_by_NID(x->cert_info->extensions, nid, lastpos));
 }
-LCRYPTO_ALIAS(X509_get_ext_by_NID)
+LCRYPTO_ALIAS(X509_get_ext_by_NID);
 
 int
 X509_get_ext_by_OBJ(const X509 *x, const ASN1_OBJECT *obj, int lastpos)
 {
 	return (X509v3_get_ext_by_OBJ(x->cert_info->extensions, obj, lastpos));
 }
-LCRYPTO_ALIAS(X509_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509_get_ext_by_OBJ);
 
 int
 X509_get_ext_by_critical(const X509 *x, int crit, int lastpos)
@@ -158,35 +158,35 @@ X509_get_ext_by_critical(const X509 *x, int crit, int lastpos)
 	return (X509v3_get_ext_by_critical(x->cert_info->extensions, crit,
 	    lastpos));
 }
-LCRYPTO_ALIAS(X509_get_ext_by_critical)
+LCRYPTO_ALIAS(X509_get_ext_by_critical);
 
 X509_EXTENSION *
 X509_get_ext(const X509 *x, int loc)
 {
 	return (X509v3_get_ext(x->cert_info->extensions, loc));
 }
-LCRYPTO_ALIAS(X509_get_ext)
+LCRYPTO_ALIAS(X509_get_ext);
 
 X509_EXTENSION *
 X509_delete_ext(X509 *x, int loc)
 {
 	return (X509v3_delete_ext(x->cert_info->extensions, loc));
 }
-LCRYPTO_ALIAS(X509_delete_ext)
+LCRYPTO_ALIAS(X509_delete_ext);
 
 int
 X509_add_ext(X509 *x, X509_EXTENSION *ex, int loc)
 {
 	return (X509v3_add_ext(&(x->cert_info->extensions), ex, loc) != NULL);
 }
-LCRYPTO_ALIAS(X509_add_ext)
+LCRYPTO_ALIAS(X509_add_ext);
 
 void *
 X509_get_ext_d2i(const X509 *x, int nid, int *crit, int *idx)
 {
 	return X509V3_get_d2i(x->cert_info->extensions, nid, crit, idx);
 }
-LCRYPTO_ALIAS(X509_get_ext_d2i)
+LCRYPTO_ALIAS(X509_get_ext_d2i);
 
 int
 X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags)
@@ -194,21 +194,21 @@ X509_add1_ext_i2d(X509 *x, int nid, void *value, int crit, unsigned long flags)
 	return X509V3_add1_i2d(&x->cert_info->extensions, nid, value, crit,
 	    flags);
 }
-LCRYPTO_ALIAS(X509_add1_ext_i2d)
+LCRYPTO_ALIAS(X509_add1_ext_i2d);
 
 int
 X509_REVOKED_get_ext_count(const X509_REVOKED *x)
 {
 	return (X509v3_get_ext_count(x->extensions));
 }
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_count)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_count);
 
 int
 X509_REVOKED_get_ext_by_NID(const X509_REVOKED *x, int nid, int lastpos)
 {
 	return (X509v3_get_ext_by_NID(x->extensions, nid, lastpos));
 }
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_NID);
 
 int
 X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
@@ -216,42 +216,42 @@ X509_REVOKED_get_ext_by_OBJ(const X509_REVOKED *x, const ASN1_OBJECT *obj,
 {
 	return (X509v3_get_ext_by_OBJ(x->extensions, obj, lastpos));
 }
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_OBJ);
 
 int
 X509_REVOKED_get_ext_by_critical(const X509_REVOKED *x, int crit, int lastpos)
 {
 	return (X509v3_get_ext_by_critical(x->extensions, crit, lastpos));
 }
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_by_critical);
 
 X509_EXTENSION *
 X509_REVOKED_get_ext(const X509_REVOKED *x, int loc)
 {
 	return (X509v3_get_ext(x->extensions, loc));
 }
-LCRYPTO_ALIAS(X509_REVOKED_get_ext)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext);
 
 X509_EXTENSION *
 X509_REVOKED_delete_ext(X509_REVOKED *x, int loc)
 {
 	return (X509v3_delete_ext(x->extensions, loc));
 }
-LCRYPTO_ALIAS(X509_REVOKED_delete_ext)
+LCRYPTO_ALIAS(X509_REVOKED_delete_ext);
 
 int
 X509_REVOKED_add_ext(X509_REVOKED *x, X509_EXTENSION *ex, int loc)
 {
 	return (X509v3_add_ext(&(x->extensions), ex, loc) != NULL);
 }
-LCRYPTO_ALIAS(X509_REVOKED_add_ext)
+LCRYPTO_ALIAS(X509_REVOKED_add_ext);
 
 void *
 X509_REVOKED_get_ext_d2i(const X509_REVOKED *x, int nid, int *crit, int *idx)
 {
 	return X509V3_get_d2i(x->extensions, nid, crit, idx);
 }
-LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i)
+LCRYPTO_ALIAS(X509_REVOKED_get_ext_d2i);
 
 int
 X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
@@ -259,4 +259,4 @@ X509_REVOKED_add1_ext_i2d(X509_REVOKED *x, int nid, void *value, int crit,
 {
 	return X509V3_add1_i2d(&x->extensions, nid, value, crit, flags);
 }
-LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d)
+LCRYPTO_ALIAS(X509_REVOKED_add1_ext_i2d);
diff --git a/lib/libcrypto/x509/x509_extku.c b/lib/libcrypto/x509/x509_extku.c
index cfdb23df75e..94032f624e7 100644
--- a/lib/libcrypto/x509/x509_extku.c
+++ b/lib/libcrypto/x509/x509_extku.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_extku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_extku.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -128,28 +128,28 @@ d2i_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE **a, const unsigned char **in, long le
 	return (EXTENDED_KEY_USAGE *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &EXTENDED_KEY_USAGE_it);
 }
-LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE)
+LCRYPTO_ALIAS(d2i_EXTENDED_KEY_USAGE);
 
 int
 i2d_EXTENDED_KEY_USAGE(EXTENDED_KEY_USAGE *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &EXTENDED_KEY_USAGE_it);
 }
-LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE)
+LCRYPTO_ALIAS(i2d_EXTENDED_KEY_USAGE);
 
 EXTENDED_KEY_USAGE *
 EXTENDED_KEY_USAGE_new(void)
 {
 	return (EXTENDED_KEY_USAGE *)ASN1_item_new(&EXTENDED_KEY_USAGE_it);
 }
-LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new)
+LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_new);
 
 void
 EXTENDED_KEY_USAGE_free(EXTENDED_KEY_USAGE *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &EXTENDED_KEY_USAGE_it);
 }
-LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free)
+LCRYPTO_ALIAS(EXTENDED_KEY_USAGE_free);
 
 static STACK_OF(CONF_VALUE) *
 i2v_EXTENDED_KEY_USAGE(const X509V3_EXT_METHOD *method, void *a,
diff --git a/lib/libcrypto/x509/x509_genn.c b/lib/libcrypto/x509/x509_genn.c
index 395d487f8f5..0c03396e0d2 100644
--- a/lib/libcrypto/x509/x509_genn.c
+++ b/lib/libcrypto/x509/x509_genn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_genn.c,v 1.4 2023/02/07 15:46:58 tb Exp $ */
+/* $OpenBSD: x509_genn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -98,28 +98,28 @@ d2i_OTHERNAME(OTHERNAME **a, const unsigned char **in, long len)
 	return (OTHERNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &OTHERNAME_it);
 }
-LCRYPTO_ALIAS(d2i_OTHERNAME)
+LCRYPTO_ALIAS(d2i_OTHERNAME);
 
 int
 i2d_OTHERNAME(OTHERNAME *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &OTHERNAME_it);
 }
-LCRYPTO_ALIAS(i2d_OTHERNAME)
+LCRYPTO_ALIAS(i2d_OTHERNAME);
 
 OTHERNAME *
 OTHERNAME_new(void)
 {
 	return (OTHERNAME *)ASN1_item_new(&OTHERNAME_it);
 }
-LCRYPTO_ALIAS(OTHERNAME_new)
+LCRYPTO_ALIAS(OTHERNAME_new);
 
 void
 OTHERNAME_free(OTHERNAME *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &OTHERNAME_it);
 }
-LCRYPTO_ALIAS(OTHERNAME_free)
+LCRYPTO_ALIAS(OTHERNAME_free);
 
 /* Uses explicit tagging since DIRECTORYSTRING is a CHOICE type */
 static const ASN1_TEMPLATE EDIPARTYNAME_seq_tt[] = {
@@ -156,28 +156,28 @@ d2i_EDIPARTYNAME(EDIPARTYNAME **a, const unsigned char **in, long len)
 	return (EDIPARTYNAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(d2i_EDIPARTYNAME)
+LCRYPTO_ALIAS(d2i_EDIPARTYNAME);
 
 int
 i2d_EDIPARTYNAME(EDIPARTYNAME *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(i2d_EDIPARTYNAME)
+LCRYPTO_ALIAS(i2d_EDIPARTYNAME);
 
 EDIPARTYNAME *
 EDIPARTYNAME_new(void)
 {
 	return (EDIPARTYNAME *)ASN1_item_new(&EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(EDIPARTYNAME_new)
+LCRYPTO_ALIAS(EDIPARTYNAME_new);
 
 void
 EDIPARTYNAME_free(EDIPARTYNAME *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &EDIPARTYNAME_it);
 }
-LCRYPTO_ALIAS(EDIPARTYNAME_free)
+LCRYPTO_ALIAS(EDIPARTYNAME_free);
 
 static const ASN1_TEMPLATE GENERAL_NAME_ch_tt[] = {
 	{
@@ -264,28 +264,28 @@ d2i_GENERAL_NAME(GENERAL_NAME **a, const unsigned char **in, long len)
 	return (GENERAL_NAME *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(d2i_GENERAL_NAME)
+LCRYPTO_ALIAS(d2i_GENERAL_NAME);
 
 int
 i2d_GENERAL_NAME(GENERAL_NAME *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(i2d_GENERAL_NAME)
+LCRYPTO_ALIAS(i2d_GENERAL_NAME);
 
 GENERAL_NAME *
 GENERAL_NAME_new(void)
 {
 	return (GENERAL_NAME *)ASN1_item_new(&GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAME_new)
+LCRYPTO_ALIAS(GENERAL_NAME_new);
 
 void
 GENERAL_NAME_free(GENERAL_NAME *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAME_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAME_free)
+LCRYPTO_ALIAS(GENERAL_NAME_free);
 
 static const ASN1_TEMPLATE GENERAL_NAMES_item_tt = {
 	.flags = ASN1_TFLG_SEQUENCE_OF,
@@ -312,35 +312,35 @@ d2i_GENERAL_NAMES(GENERAL_NAMES **a, const unsigned char **in, long len)
 	return (GENERAL_NAMES *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(d2i_GENERAL_NAMES)
+LCRYPTO_ALIAS(d2i_GENERAL_NAMES);
 
 int
 i2d_GENERAL_NAMES(GENERAL_NAMES *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(i2d_GENERAL_NAMES)
+LCRYPTO_ALIAS(i2d_GENERAL_NAMES);
 
 GENERAL_NAMES *
 GENERAL_NAMES_new(void)
 {
 	return (GENERAL_NAMES *)ASN1_item_new(&GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAMES_new)
+LCRYPTO_ALIAS(GENERAL_NAMES_new);
 
 void
 GENERAL_NAMES_free(GENERAL_NAMES *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &GENERAL_NAMES_it);
 }
-LCRYPTO_ALIAS(GENERAL_NAMES_free)
+LCRYPTO_ALIAS(GENERAL_NAMES_free);
 
 GENERAL_NAME *
 GENERAL_NAME_dup(GENERAL_NAME *a)
 {
 	return ASN1_item_dup(&GENERAL_NAME_it, a);
 }
-LCRYPTO_ALIAS(GENERAL_NAME_dup)
+LCRYPTO_ALIAS(GENERAL_NAME_dup);
 
 static int
 EDIPARTYNAME_cmp(const EDIPARTYNAME *a, const EDIPARTYNAME *b)
@@ -415,7 +415,7 @@ GENERAL_NAME_cmp(GENERAL_NAME *a, GENERAL_NAME *b)
 	}
 	return result;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_cmp)
+LCRYPTO_ALIAS(GENERAL_NAME_cmp);
 
 /* Returns 0 if they are equal, != 0 otherwise. */
 int
@@ -432,7 +432,7 @@ OTHERNAME_cmp(OTHERNAME *a, OTHERNAME *b)
 	result = ASN1_TYPE_cmp(a->value, b->value);
 	return result;
 }
-LCRYPTO_ALIAS(OTHERNAME_cmp)
+LCRYPTO_ALIAS(OTHERNAME_cmp);
 
 void
 GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
@@ -470,7 +470,7 @@ GENERAL_NAME_set0_value(GENERAL_NAME *a, int type, void *value)
 	}
 	a->type = type;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_set0_value)
+LCRYPTO_ALIAS(GENERAL_NAME_set0_value);
 
 void *
 GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
@@ -505,7 +505,7 @@ GENERAL_NAME_get0_value(GENERAL_NAME *a, int *ptype)
 		return NULL;
 	}
 }
-LCRYPTO_ALIAS(GENERAL_NAME_get0_value)
+LCRYPTO_ALIAS(GENERAL_NAME_get0_value);
 
 int
 GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
@@ -521,7 +521,7 @@ GENERAL_NAME_set0_othername(GENERAL_NAME *gen, ASN1_OBJECT *oid,
 	GENERAL_NAME_set0_value(gen, GEN_OTHERNAME, oth);
 	return 1;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_set0_othername)
+LCRYPTO_ALIAS(GENERAL_NAME_set0_othername);
 
 int
 GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
@@ -535,4 +535,4 @@ GENERAL_NAME_get0_otherName(GENERAL_NAME *gen, ASN1_OBJECT **poid,
 		*pvalue = gen->d.otherName->value;
 	return 1;
 }
-LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName)
+LCRYPTO_ALIAS(GENERAL_NAME_get0_otherName);
diff --git a/lib/libcrypto/x509/x509_info.c b/lib/libcrypto/x509/x509_info.c
index 6c7fd13601e..a3d4d1bcc7b 100644
--- a/lib/libcrypto/x509/x509_info.c
+++ b/lib/libcrypto/x509/x509_info.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_info.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_info.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -139,28 +139,28 @@ d2i_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION **a, const unsigned char **in, long le
 	return (ACCESS_DESCRIPTION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &ACCESS_DESCRIPTION_it);
 }
-LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION)
+LCRYPTO_ALIAS(d2i_ACCESS_DESCRIPTION);
 
 int
 i2d_ACCESS_DESCRIPTION(ACCESS_DESCRIPTION *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &ACCESS_DESCRIPTION_it);
 }
-LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION)
+LCRYPTO_ALIAS(i2d_ACCESS_DESCRIPTION);
 
 ACCESS_DESCRIPTION *
 ACCESS_DESCRIPTION_new(void)
 {
 	return (ACCESS_DESCRIPTION *)ASN1_item_new(&ACCESS_DESCRIPTION_it);
 }
-LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new)
+LCRYPTO_ALIAS(ACCESS_DESCRIPTION_new);
 
 void
 ACCESS_DESCRIPTION_free(ACCESS_DESCRIPTION *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &ACCESS_DESCRIPTION_it);
 }
-LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free)
+LCRYPTO_ALIAS(ACCESS_DESCRIPTION_free);
 
 static const ASN1_TEMPLATE AUTHORITY_INFO_ACCESS_item_tt = {
 	.flags = ASN1_TFLG_SEQUENCE_OF,
@@ -187,28 +187,28 @@ d2i_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS **a, const unsigned char **in, l
 	return (AUTHORITY_INFO_ACCESS *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &AUTHORITY_INFO_ACCESS_it);
 }
-LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS)
+LCRYPTO_ALIAS(d2i_AUTHORITY_INFO_ACCESS);
 
 int
 i2d_AUTHORITY_INFO_ACCESS(AUTHORITY_INFO_ACCESS *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &AUTHORITY_INFO_ACCESS_it);
 }
-LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS)
+LCRYPTO_ALIAS(i2d_AUTHORITY_INFO_ACCESS);
 
 AUTHORITY_INFO_ACCESS *
 AUTHORITY_INFO_ACCESS_new(void)
 {
 	return (AUTHORITY_INFO_ACCESS *)ASN1_item_new(&AUTHORITY_INFO_ACCESS_it);
 }
-LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new)
+LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_new);
 
 void
 AUTHORITY_INFO_ACCESS_free(AUTHORITY_INFO_ACCESS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &AUTHORITY_INFO_ACCESS_it);
 }
-LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free)
+LCRYPTO_ALIAS(AUTHORITY_INFO_ACCESS_free);
 
 static STACK_OF(CONF_VALUE) *
 i2v_AUTHORITY_INFO_ACCESS(X509V3_EXT_METHOD *method,
@@ -314,4 +314,4 @@ i2a_ACCESS_DESCRIPTION(BIO *bp, const ACCESS_DESCRIPTION* a)
 	i2a_ASN1_OBJECT(bp, a->method);
 	return 2;
 }
-LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION)
+LCRYPTO_ALIAS(i2a_ACCESS_DESCRIPTION);
diff --git a/lib/libcrypto/x509/x509_lib.c b/lib/libcrypto/x509/x509_lib.c
index f27e3315aaa..97d54edd3f4 100644
--- a/lib/libcrypto/x509/x509_lib.c
+++ b/lib/libcrypto/x509/x509_lib.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_lib.c,v 1.6 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_lib.c,v 1.7 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -85,7 +85,7 @@ X509V3_EXT_add(X509V3_EXT_METHOD *ext)
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_EXT_add)
+LCRYPTO_ALIAS(X509V3_EXT_add);
 
 static int
 ext_cmp(const X509V3_EXT_METHOD * const *a, const X509V3_EXT_METHOD * const *b)
@@ -133,7 +133,7 @@ X509V3_EXT_get_nid(int nid)
 		return NULL;
 	return sk_X509V3_EXT_METHOD_value(ext_list, idx);
 }
-LCRYPTO_ALIAS(X509V3_EXT_get_nid)
+LCRYPTO_ALIAS(X509V3_EXT_get_nid);
 
 const X509V3_EXT_METHOD *
 X509V3_EXT_get(X509_EXTENSION *ext)
@@ -144,7 +144,7 @@ X509V3_EXT_get(X509_EXTENSION *ext)
 		return NULL;
 	return X509V3_EXT_get_nid(nid);
 }
-LCRYPTO_ALIAS(X509V3_EXT_get)
+LCRYPTO_ALIAS(X509V3_EXT_get);
 
 int
 X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist)
@@ -154,7 +154,7 @@ X509V3_EXT_add_list(X509V3_EXT_METHOD *extlist)
 			return 0;
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_EXT_add_list)
+LCRYPTO_ALIAS(X509V3_EXT_add_list);
 
 int
 X509V3_EXT_add_alias(int nid_to, int nid_from)
@@ -179,7 +179,7 @@ X509V3_EXT_add_alias(int nid_to, int nid_from)
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_EXT_add_alias)
+LCRYPTO_ALIAS(X509V3_EXT_add_alias);
 
 void
 X509V3_EXT_cleanup(void)
@@ -187,7 +187,7 @@ X509V3_EXT_cleanup(void)
 	sk_X509V3_EXT_METHOD_pop_free(ext_list, ext_list_free);
 	ext_list = NULL;
 }
-LCRYPTO_ALIAS(X509V3_EXT_cleanup)
+LCRYPTO_ALIAS(X509V3_EXT_cleanup);
 
 static void
 ext_list_free(X509V3_EXT_METHOD *ext)
@@ -205,7 +205,7 @@ X509V3_add_standard_extensions(void)
 {
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_add_standard_extensions)
+LCRYPTO_ALIAS(X509V3_add_standard_extensions);
 
 /* Return an extension internal structure */
 
@@ -223,7 +223,7 @@ X509V3_EXT_d2i(X509_EXTENSION *ext)
 		    method->it);
 	return method->d2i(NULL, &p, ext->value->length);
 }
-LCRYPTO_ALIAS(X509V3_EXT_d2i)
+LCRYPTO_ALIAS(X509V3_EXT_d2i);
 
 /* Get critical flag and decoded version of extension from a NID.
  * The "idx" variable returns the last found extension and can
@@ -289,7 +289,7 @@ X509V3_get_d2i(const STACK_OF(X509_EXTENSION) *x, int nid, int *crit, int *idx)
 		*crit = -1;
 	return NULL;
 }
-LCRYPTO_ALIAS(X509V3_get_d2i)
+LCRYPTO_ALIAS(X509V3_get_d2i);
 
 /* This function is a general extension append, replace and delete utility.
  * The precise operation is governed by the 'flags' value. The 'crit' and
@@ -371,4 +371,4 @@ err:
 		X509V3error(errcode);
 	return 0;
 }
-LCRYPTO_ALIAS(X509V3_add1_i2d)
+LCRYPTO_ALIAS(X509V3_add1_i2d);
diff --git a/lib/libcrypto/x509/x509_lu.c b/lib/libcrypto/x509/x509_lu.c
index 28cb85035b2..65d11d91079 100644
--- a/lib/libcrypto/x509/x509_lu.c
+++ b/lib/libcrypto/x509/x509_lu.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_lu.c,v 1.57 2022/11/26 16:08:54 tb Exp $ */
+/* $OpenBSD: x509_lu.c,v 1.58 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -84,7 +84,7 @@ X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
 
 	return lu;
 }
-LCRYPTO_ALIAS(X509_LOOKUP_new)
+LCRYPTO_ALIAS(X509_LOOKUP_new);
 
 void
 X509_LOOKUP_free(X509_LOOKUP *ctx)
@@ -95,7 +95,7 @@ X509_LOOKUP_free(X509_LOOKUP *ctx)
 		ctx->method->free(ctx);
 	free(ctx);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_free)
+LCRYPTO_ALIAS(X509_LOOKUP_free);
 
 int
 X509_LOOKUP_init(X509_LOOKUP *ctx)
@@ -106,7 +106,7 @@ X509_LOOKUP_init(X509_LOOKUP *ctx)
 		return 1;
 	return ctx->method->init(ctx);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_init)
+LCRYPTO_ALIAS(X509_LOOKUP_init);
 
 int
 X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
@@ -117,7 +117,7 @@ X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
 		return 1;
 	return ctx->method->shutdown(ctx);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_shutdown)
+LCRYPTO_ALIAS(X509_LOOKUP_shutdown);
 
 int
 X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
@@ -129,7 +129,7 @@ X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
 		return 1;
 	return ctx->method->ctrl(ctx, cmd, argc, argl, ret);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_ctrl)
+LCRYPTO_ALIAS(X509_LOOKUP_ctrl);
 
 int
 X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name,
@@ -139,7 +139,7 @@ X509_LOOKUP_by_subject(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, X509_NAME *name,
 		return 0;
 	return ctx->method->get_by_subject(ctx, type, name, ret);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_by_subject)
+LCRYPTO_ALIAS(X509_LOOKUP_by_subject);
 
 int
 X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
@@ -149,7 +149,7 @@ X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
 		return 0;
 	return ctx->method->get_by_issuer_serial(ctx, type, name, serial, ret);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial)
+LCRYPTO_ALIAS(X509_LOOKUP_by_issuer_serial);
 
 int
 X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
@@ -159,7 +159,7 @@ X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type,
 		return 0;
 	return ctx->method->get_by_fingerprint(ctx, type, bytes, len, ret);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint)
+LCRYPTO_ALIAS(X509_LOOKUP_by_fingerprint);
 
 int
 X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str,
@@ -169,7 +169,7 @@ X509_LOOKUP_by_alias(X509_LOOKUP *ctx, X509_LOOKUP_TYPE type, const char *str,
 		return 0;
 	return ctx->method->get_by_alias(ctx, type, str, len, ret);
 }
-LCRYPTO_ALIAS(X509_LOOKUP_by_alias)
+LCRYPTO_ALIAS(X509_LOOKUP_by_alias);
 
 static int
 x509_object_cmp(const X509_OBJECT * const *a, const X509_OBJECT * const *b)
@@ -217,7 +217,7 @@ X509_STORE_new(void)
 
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_STORE_new)
+LCRYPTO_ALIAS(X509_STORE_new);
 
 X509_OBJECT *
 X509_OBJECT_new(void)
@@ -233,7 +233,7 @@ X509_OBJECT_new(void)
 
 	return obj;
 }
-LCRYPTO_ALIAS(X509_OBJECT_new)
+LCRYPTO_ALIAS(X509_OBJECT_new);
 
 void
 X509_OBJECT_free(X509_OBJECT *a)
@@ -252,7 +252,7 @@ X509_OBJECT_free(X509_OBJECT *a)
 
 	free(a);
 }
-LCRYPTO_ALIAS(X509_OBJECT_free)
+LCRYPTO_ALIAS(X509_OBJECT_free);
 
 void
 X509_STORE_free(X509_STORE *store)
@@ -280,14 +280,14 @@ X509_STORE_free(X509_STORE *store)
 	X509_VERIFY_PARAM_free(store->param);
 	free(store);
 }
-LCRYPTO_ALIAS(X509_STORE_free)
+LCRYPTO_ALIAS(X509_STORE_free);
 
 int
 X509_STORE_up_ref(X509_STORE *store)
 {
 	return CRYPTO_add(&store->references, 1, CRYPTO_LOCK_X509_STORE) > 1;
 }
-LCRYPTO_ALIAS(X509_STORE_up_ref)
+LCRYPTO_ALIAS(X509_STORE_up_ref);
 
 X509_LOOKUP *
 X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method)
@@ -316,7 +316,7 @@ X509_STORE_add_lookup(X509_STORE *store, X509_LOOKUP_METHOD *method)
 
 	return lu;
 }
-LCRYPTO_ALIAS(X509_STORE_add_lookup)
+LCRYPTO_ALIAS(X509_STORE_add_lookup);
 
 X509_OBJECT *
 X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
@@ -333,7 +333,7 @@ X509_STORE_CTX_get_obj_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
 
 	return obj;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_obj_by_subject);
 
 int
 X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
@@ -372,7 +372,7 @@ X509_STORE_CTX_get_by_subject(X509_STORE_CTX *vs, X509_LOOKUP_TYPE type,
 
 	return 1;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_by_subject);
 
 /* Add obj to the store. Takes ownership of obj. */
 static int
@@ -424,7 +424,7 @@ X509_STORE_add_cert(X509_STORE *store, X509 *x)
 
 	return X509_STORE_add_object(store, obj);
 }
-LCRYPTO_ALIAS(X509_STORE_add_cert)
+LCRYPTO_ALIAS(X509_STORE_add_cert);
 
 int
 X509_STORE_add_crl(X509_STORE *store, X509_CRL *x)
@@ -447,7 +447,7 @@ X509_STORE_add_crl(X509_STORE *store, X509_CRL *x)
 
 	return X509_STORE_add_object(store, obj);
 }
-LCRYPTO_ALIAS(X509_STORE_add_crl)
+LCRYPTO_ALIAS(X509_STORE_add_crl);
 
 int
 X509_OBJECT_up_ref_count(X509_OBJECT *a)
@@ -460,14 +460,14 @@ X509_OBJECT_up_ref_count(X509_OBJECT *a)
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509_OBJECT_up_ref_count)
+LCRYPTO_ALIAS(X509_OBJECT_up_ref_count);
 
 X509_LOOKUP_TYPE
 X509_OBJECT_get_type(const X509_OBJECT *a)
 {
 	return a->type;
 }
-LCRYPTO_ALIAS(X509_OBJECT_get_type)
+LCRYPTO_ALIAS(X509_OBJECT_get_type);
 
 static int
 x509_object_idx_cnt(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
@@ -519,7 +519,7 @@ X509_OBJECT_idx_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
 {
 	return x509_object_idx_cnt(h, type, name, NULL);
 }
-LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject)
+LCRYPTO_ALIAS(X509_OBJECT_idx_by_subject);
 
 X509_OBJECT *
 X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
@@ -532,7 +532,7 @@ X509_OBJECT_retrieve_by_subject(STACK_OF(X509_OBJECT) *h, X509_LOOKUP_TYPE type,
 		return NULL;
 	return sk_X509_OBJECT_value(h, idx);
 }
-LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject)
+LCRYPTO_ALIAS(X509_OBJECT_retrieve_by_subject);
 
 X509 *
 X509_OBJECT_get0_X509(const X509_OBJECT *xo)
@@ -541,7 +541,7 @@ X509_OBJECT_get0_X509(const X509_OBJECT *xo)
 		return xo->data.x509;
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_OBJECT_get0_X509)
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509);
 
 X509_CRL *
 X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo)
@@ -550,7 +550,7 @@ X509_OBJECT_get0_X509_CRL(X509_OBJECT *xo)
 		return xo->data.crl;
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL)
+LCRYPTO_ALIAS(X509_OBJECT_get0_X509_CRL);
 
 static STACK_OF(X509) *
 X509_get1_certs_from_cache(X509_STORE *store, X509_NAME *name)
@@ -614,7 +614,7 @@ X509_STORE_get1_certs(X509_STORE_CTX *ctx, X509_NAME *name)
 
 	return X509_get1_certs_from_cache(store, name);
 }
-LCRYPTO_ALIAS(X509_STORE_get1_certs)
+LCRYPTO_ALIAS(X509_STORE_get1_certs);
 
 STACK_OF(X509_CRL) *
 X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name)
@@ -665,7 +665,7 @@ X509_STORE_get1_crls(X509_STORE_CTX *ctx, X509_NAME *name)
 	sk_X509_CRL_pop_free(sk, X509_CRL_free);
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_STORE_get1_crls)
+LCRYPTO_ALIAS(X509_STORE_get1_crls);
 
 X509_OBJECT *
 X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
@@ -694,7 +694,7 @@ X509_OBJECT_retrieve_match(STACK_OF(X509_OBJECT) *h, X509_OBJECT *x)
 	}
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_OBJECT_retrieve_match)
+LCRYPTO_ALIAS(X509_OBJECT_retrieve_match);
 
 /* Try to get issuer certificate from store. Due to limitations
  * of the API this can only retrieve a single certificate matching
@@ -785,35 +785,35 @@ X509_STORE_CTX_get1_issuer(X509 **out_issuer, X509_STORE_CTX *ctx, X509 *x)
 	CRYPTO_w_unlock(CRYPTO_LOCK_X509_STORE);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer)
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_issuer);
 
 STACK_OF(X509_OBJECT) *
 X509_STORE_get0_objects(X509_STORE *xs)
 {
 	return xs->objs;
 }
-LCRYPTO_ALIAS(X509_STORE_get0_objects)
+LCRYPTO_ALIAS(X509_STORE_get0_objects);
 
 void *
 X509_STORE_get_ex_data(X509_STORE *xs, int idx)
 {
 	return CRYPTO_get_ex_data(&xs->ex_data, idx);
 }
-LCRYPTO_ALIAS(X509_STORE_get_ex_data)
+LCRYPTO_ALIAS(X509_STORE_get_ex_data);
 
 int
 X509_STORE_set_ex_data(X509_STORE *xs, int idx, void *data)
 {
 	return CRYPTO_set_ex_data(&xs->ex_data, idx, data);
 }
-LCRYPTO_ALIAS(X509_STORE_set_ex_data)
+LCRYPTO_ALIAS(X509_STORE_set_ex_data);
 
 int
 X509_STORE_set_flags(X509_STORE *ctx, unsigned long flags)
 {
 	return X509_VERIFY_PARAM_set_flags(ctx->param, flags);
 }
-LCRYPTO_ALIAS(X509_STORE_set_flags)
+LCRYPTO_ALIAS(X509_STORE_set_flags);
 
 int
 X509_STORE_set_depth(X509_STORE *ctx, int depth)
@@ -821,60 +821,60 @@ X509_STORE_set_depth(X509_STORE *ctx, int depth)
 	X509_VERIFY_PARAM_set_depth(ctx->param, depth);
 	return 1;
 }
-LCRYPTO_ALIAS(X509_STORE_set_depth)
+LCRYPTO_ALIAS(X509_STORE_set_depth);
 
 int
 X509_STORE_set_purpose(X509_STORE *ctx, int purpose)
 {
 	return X509_VERIFY_PARAM_set_purpose(ctx->param, purpose);
 }
-LCRYPTO_ALIAS(X509_STORE_set_purpose)
+LCRYPTO_ALIAS(X509_STORE_set_purpose);
 
 int
 X509_STORE_set_trust(X509_STORE *ctx, int trust)
 {
 	return X509_VERIFY_PARAM_set_trust(ctx->param, trust);
 }
-LCRYPTO_ALIAS(X509_STORE_set_trust)
+LCRYPTO_ALIAS(X509_STORE_set_trust);
 
 int
 X509_STORE_set1_param(X509_STORE *ctx, X509_VERIFY_PARAM *param)
 {
 	return X509_VERIFY_PARAM_set1(ctx->param, param);
 }
-LCRYPTO_ALIAS(X509_STORE_set1_param)
+LCRYPTO_ALIAS(X509_STORE_set1_param);
 
 X509_VERIFY_PARAM *
 X509_STORE_get0_param(X509_STORE *ctx)
 {
 	return ctx->param;
 }
-LCRYPTO_ALIAS(X509_STORE_get0_param)
+LCRYPTO_ALIAS(X509_STORE_get0_param);
 
 void
 X509_STORE_set_verify(X509_STORE *store, X509_STORE_CTX_verify_fn verify)
 {
 	store->verify = verify;
 }
-LCRYPTO_ALIAS(X509_STORE_set_verify)
+LCRYPTO_ALIAS(X509_STORE_set_verify);
 
 X509_STORE_CTX_verify_fn
 X509_STORE_get_verify(X509_STORE *store)
 {
 	return store->verify;
 }
-LCRYPTO_ALIAS(X509_STORE_get_verify)
+LCRYPTO_ALIAS(X509_STORE_get_verify);
 
 void
 X509_STORE_set_verify_cb(X509_STORE *store, X509_STORE_CTX_verify_cb verify_cb)
 {
 	store->verify_cb = verify_cb;
 }
-LCRYPTO_ALIAS(X509_STORE_set_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_set_verify_cb);
 
 X509_STORE_CTX_verify_cb
 X509_STORE_get_verify_cb(X509_STORE *store)
 {
 	return store->verify_cb;
 }
-LCRYPTO_ALIAS(X509_STORE_get_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_get_verify_cb);
diff --git a/lib/libcrypto/x509/x509_ncons.c b/lib/libcrypto/x509/x509_ncons.c
index c7e4e6ed9f5..159e3c25636 100644
--- a/lib/libcrypto/x509/x509_ncons.c
+++ b/lib/libcrypto/x509/x509_ncons.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_ncons.c,v 1.8 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509_ncons.c,v 1.9 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -165,28 +165,28 @@ GENERAL_SUBTREE_new(void)
 {
 	return (GENERAL_SUBTREE*)ASN1_item_new(&GENERAL_SUBTREE_it);
 }
-LCRYPTO_ALIAS(GENERAL_SUBTREE_new)
+LCRYPTO_ALIAS(GENERAL_SUBTREE_new);
 
 void
 GENERAL_SUBTREE_free(GENERAL_SUBTREE *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &GENERAL_SUBTREE_it);
 }
-LCRYPTO_ALIAS(GENERAL_SUBTREE_free)
+LCRYPTO_ALIAS(GENERAL_SUBTREE_free);
 
 NAME_CONSTRAINTS *
 NAME_CONSTRAINTS_new(void)
 {
 	return (NAME_CONSTRAINTS*)ASN1_item_new(&NAME_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(NAME_CONSTRAINTS_new)
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_new);
 
 void
 NAME_CONSTRAINTS_free(NAME_CONSTRAINTS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &NAME_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(NAME_CONSTRAINTS_free)
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_free);
 
 static void *
 v2i_NAME_CONSTRAINTS(const X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -353,7 +353,7 @@ NAME_CONSTRAINTS_check(X509 *x, NAME_CONSTRAINTS *nc)
 	}
 	return X509_V_OK;
 }
-LCRYPTO_ALIAS(NAME_CONSTRAINTS_check)
+LCRYPTO_ALIAS(NAME_CONSTRAINTS_check);
 static int
 nc_match(GENERAL_NAME *gen, NAME_CONSTRAINTS *nc)
 {
diff --git a/lib/libcrypto/x509/x509_obj.c b/lib/libcrypto/x509/x509_obj.c
index f9323cf5bc6..ea4ae6b98aa 100644
--- a/lib/libcrypto/x509/x509_obj.c
+++ b/lib/libcrypto/x509/x509_obj.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_obj.c,v 1.21 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_obj.c,v 1.22 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -179,4 +179,4 @@ err:
 		BUF_MEM_free(b);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_NAME_oneline)
+LCRYPTO_ALIAS(X509_NAME_oneline);
diff --git a/lib/libcrypto/x509/x509_pcia.c b/lib/libcrypto/x509/x509_pcia.c
index fb14384e995..ec8d03a86b9 100644
--- a/lib/libcrypto/x509/x509_pcia.c
+++ b/lib/libcrypto/x509/x509_pcia.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pcia.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pcia.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Contributed to the OpenSSL Project 2004
  * by Richard Levitte (richard@levitte.org)
  */
@@ -72,28 +72,28 @@ d2i_PROXY_POLICY(PROXY_POLICY **a, const unsigned char **in, long len)
 	return (PROXY_POLICY *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PROXY_POLICY_it);
 }
-LCRYPTO_ALIAS(d2i_PROXY_POLICY)
+LCRYPTO_ALIAS(d2i_PROXY_POLICY);
 
 int
 i2d_PROXY_POLICY(PROXY_POLICY *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_POLICY_it);
 }
-LCRYPTO_ALIAS(i2d_PROXY_POLICY)
+LCRYPTO_ALIAS(i2d_PROXY_POLICY);
 
 PROXY_POLICY *
 PROXY_POLICY_new(void)
 {
 	return (PROXY_POLICY *)ASN1_item_new(&PROXY_POLICY_it);
 }
-LCRYPTO_ALIAS(PROXY_POLICY_new)
+LCRYPTO_ALIAS(PROXY_POLICY_new);
 
 void
 PROXY_POLICY_free(PROXY_POLICY *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PROXY_POLICY_it);
 }
-LCRYPTO_ALIAS(PROXY_POLICY_free)
+LCRYPTO_ALIAS(PROXY_POLICY_free);
 
 static const ASN1_TEMPLATE PROXY_CERT_INFO_EXTENSION_seq_tt[] = {
 	{
@@ -129,25 +129,25 @@ d2i_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION **a, const unsigned char
 	return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PROXY_CERT_INFO_EXTENSION_it);
 }
-LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION)
+LCRYPTO_ALIAS(d2i_PROXY_CERT_INFO_EXTENSION);
 
 int
 i2d_PROXY_CERT_INFO_EXTENSION(PROXY_CERT_INFO_EXTENSION *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PROXY_CERT_INFO_EXTENSION_it);
 }
-LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION)
+LCRYPTO_ALIAS(i2d_PROXY_CERT_INFO_EXTENSION);
 
 PROXY_CERT_INFO_EXTENSION *
 PROXY_CERT_INFO_EXTENSION_new(void)
 {
 	return (PROXY_CERT_INFO_EXTENSION *)ASN1_item_new(&PROXY_CERT_INFO_EXTENSION_it);
 }
-LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new)
+LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_new);
 
 void
 PROXY_CERT_INFO_EXTENSION_free(PROXY_CERT_INFO_EXTENSION *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PROXY_CERT_INFO_EXTENSION_it);
 }
-LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free)
+LCRYPTO_ALIAS(PROXY_CERT_INFO_EXTENSION_free);
diff --git a/lib/libcrypto/x509/x509_pcons.c b/lib/libcrypto/x509/x509_pcons.c
index 2448147fdb7..0ee935540f8 100644
--- a/lib/libcrypto/x509/x509_pcons.c
+++ b/lib/libcrypto/x509/x509_pcons.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pcons.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pcons.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -121,14 +121,14 @@ POLICY_CONSTRAINTS_new(void)
 {
 	return (POLICY_CONSTRAINTS*)ASN1_item_new(&POLICY_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new)
+LCRYPTO_ALIAS(POLICY_CONSTRAINTS_new);
 
 void
 POLICY_CONSTRAINTS_free(POLICY_CONSTRAINTS *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &POLICY_CONSTRAINTS_it);
 }
-LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free)
+LCRYPTO_ALIAS(POLICY_CONSTRAINTS_free);
 
 static STACK_OF(CONF_VALUE) *
 i2v_POLICY_CONSTRAINTS(const X509V3_EXT_METHOD *method, void *a,
diff --git a/lib/libcrypto/x509/x509_pku.c b/lib/libcrypto/x509/x509_pku.c
index f65d0dfc697..dd28077de10 100644
--- a/lib/libcrypto/x509/x509_pku.c
+++ b/lib/libcrypto/x509/x509_pku.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pku.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pku.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -116,28 +116,28 @@ d2i_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD **a, const unsigned char **in, long len)
 	return (PKEY_USAGE_PERIOD *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &PKEY_USAGE_PERIOD_it);
 }
-LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD)
+LCRYPTO_ALIAS(d2i_PKEY_USAGE_PERIOD);
 
 int
 i2d_PKEY_USAGE_PERIOD(PKEY_USAGE_PERIOD *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &PKEY_USAGE_PERIOD_it);
 }
-LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD)
+LCRYPTO_ALIAS(i2d_PKEY_USAGE_PERIOD);
 
 PKEY_USAGE_PERIOD *
 PKEY_USAGE_PERIOD_new(void)
 {
 	return (PKEY_USAGE_PERIOD *)ASN1_item_new(&PKEY_USAGE_PERIOD_it);
 }
-LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new)
+LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_new);
 
 void
 PKEY_USAGE_PERIOD_free(PKEY_USAGE_PERIOD *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &PKEY_USAGE_PERIOD_it);
 }
-LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free)
+LCRYPTO_ALIAS(PKEY_USAGE_PERIOD_free);
 
 static int
 i2r_PKEY_USAGE_PERIOD(X509V3_EXT_METHOD *method, PKEY_USAGE_PERIOD *usage,
diff --git a/lib/libcrypto/x509/x509_pmaps.c b/lib/libcrypto/x509/x509_pmaps.c
index 3bc4b9d6379..39aebfee866 100644
--- a/lib/libcrypto/x509/x509_pmaps.c
+++ b/lib/libcrypto/x509/x509_pmaps.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_pmaps.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_pmaps.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -137,14 +137,14 @@ POLICY_MAPPING_new(void)
 {
 	return (POLICY_MAPPING*)ASN1_item_new(&POLICY_MAPPING_it);
 }
-LCRYPTO_ALIAS(POLICY_MAPPING_new)
+LCRYPTO_ALIAS(POLICY_MAPPING_new);
 
 void
 POLICY_MAPPING_free(POLICY_MAPPING *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &POLICY_MAPPING_it);
 }
-LCRYPTO_ALIAS(POLICY_MAPPING_free)
+LCRYPTO_ALIAS(POLICY_MAPPING_free);
 
 static STACK_OF(CONF_VALUE) *
 i2v_POLICY_MAPPINGS(const X509V3_EXT_METHOD *method, void *a,
diff --git a/lib/libcrypto/x509/x509_prn.c b/lib/libcrypto/x509/x509_prn.c
index 89cd555fc58..2d7afb9fcc4 100644
--- a/lib/libcrypto/x509/x509_prn.c
+++ b/lib/libcrypto/x509/x509_prn.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_prn.c,v 1.4 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_prn.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -99,7 +99,7 @@ X509V3_EXT_val_prn(BIO *out, STACK_OF(CONF_VALUE) *val, int indent, int ml)
 			BIO_puts(out, "\n");
 	}
 }
-LCRYPTO_ALIAS(X509V3_EXT_val_prn)
+LCRYPTO_ALIAS(X509V3_EXT_val_prn);
 
 /* Main routine: print out a general extension */
 
@@ -153,7 +153,7 @@ err:
 		method->ext_free(ext_str);
 	return ok;
 }
-LCRYPTO_ALIAS(X509V3_EXT_print)
+LCRYPTO_ALIAS(X509V3_EXT_print);
 
 int
 X509V3_extensions_print(BIO *bp, const char *title,
@@ -189,7 +189,7 @@ X509V3_extensions_print(BIO *bp, const char *title,
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_extensions_print)
+LCRYPTO_ALIAS(X509V3_extensions_print);
 
 static int
 unknown_ext_print(BIO *out, X509_EXTENSION *ext, unsigned long flag,
@@ -228,4 +228,4 @@ X509V3_EXT_print_fp(FILE *fp, X509_EXTENSION *ext, int flag, int indent)
 	BIO_free(bio_tmp);
 	return ret;
 }
-LCRYPTO_ALIAS(X509V3_EXT_print_fp)
+LCRYPTO_ALIAS(X509V3_EXT_print_fp);
diff --git a/lib/libcrypto/x509/x509_purp.c b/lib/libcrypto/x509/x509_purp.c
index 7ec986062fd..63d1df2961f 100644
--- a/lib/libcrypto/x509/x509_purp.c
+++ b/lib/libcrypto/x509/x509_purp.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_purp.c,v 1.19 2023/01/20 22:00:47 job Exp $ */
+/* $OpenBSD: x509_purp.c,v 1.20 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2001.
  */
@@ -140,7 +140,7 @@ X509_check_purpose(X509 *x, int id, int ca)
 	pt = X509_PURPOSE_get0(idx);
 	return pt->check_purpose(pt, x, ca);
 }
-LCRYPTO_ALIAS(X509_check_purpose)
+LCRYPTO_ALIAS(X509_check_purpose);
 
 int
 X509_PURPOSE_set(int *p, int purpose)
@@ -152,7 +152,7 @@ X509_PURPOSE_set(int *p, int purpose)
 	*p = purpose;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_set)
+LCRYPTO_ALIAS(X509_PURPOSE_set);
 
 int
 X509_PURPOSE_get_count(void)
@@ -161,7 +161,7 @@ X509_PURPOSE_get_count(void)
 		return X509_PURPOSE_COUNT;
 	return sk_X509_PURPOSE_num(xptable) + X509_PURPOSE_COUNT;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get_count)
+LCRYPTO_ALIAS(X509_PURPOSE_get_count);
 
 X509_PURPOSE *
 X509_PURPOSE_get0(int idx)
@@ -172,7 +172,7 @@ X509_PURPOSE_get0(int idx)
 		return xstandard + idx;
 	return sk_X509_PURPOSE_value(xptable, idx - X509_PURPOSE_COUNT);
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get0)
+LCRYPTO_ALIAS(X509_PURPOSE_get0);
 
 int
 X509_PURPOSE_get_by_sname(const char *sname)
@@ -187,7 +187,7 @@ X509_PURPOSE_get_by_sname(const char *sname)
 	}
 	return -1;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname)
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_sname);
 
 int
 X509_PURPOSE_get_by_id(int purpose)
@@ -205,7 +205,7 @@ X509_PURPOSE_get_by_id(int purpose)
 		return -1;
 	return idx + X509_PURPOSE_COUNT;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get_by_id)
+LCRYPTO_ALIAS(X509_PURPOSE_get_by_id);
 
 int
 X509_PURPOSE_add(int id, int trust, int flags,
@@ -280,7 +280,7 @@ err:
 	X509V3error(ERR_R_MALLOC_FAILURE);
 	return 0;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_add)
+LCRYPTO_ALIAS(X509_PURPOSE_add);
 
 static void
 xptable_free(X509_PURPOSE *p)
@@ -302,35 +302,35 @@ X509_PURPOSE_cleanup(void)
 	sk_X509_PURPOSE_pop_free(xptable, xptable_free);
 	xptable = NULL;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_cleanup)
+LCRYPTO_ALIAS(X509_PURPOSE_cleanup);
 
 int
 X509_PURPOSE_get_id(const X509_PURPOSE *xp)
 {
 	return xp->purpose;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get_id)
+LCRYPTO_ALIAS(X509_PURPOSE_get_id);
 
 char *
 X509_PURPOSE_get0_name(const X509_PURPOSE *xp)
 {
 	return xp->name;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get0_name)
+LCRYPTO_ALIAS(X509_PURPOSE_get0_name);
 
 char *
 X509_PURPOSE_get0_sname(const X509_PURPOSE *xp)
 {
 	return xp->sname;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get0_sname)
+LCRYPTO_ALIAS(X509_PURPOSE_get0_sname);
 
 int
 X509_PURPOSE_get_trust(const X509_PURPOSE *xp)
 {
 	return xp->trust;
 }
-LCRYPTO_ALIAS(X509_PURPOSE_get_trust)
+LCRYPTO_ALIAS(X509_PURPOSE_get_trust);
 
 static int
 nid_cmp(const int *a, const int *b)
@@ -396,7 +396,7 @@ X509_supported_extension(X509_EXTENSION *ex)
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_supported_extension)
+LCRYPTO_ALIAS(X509_supported_extension);
 
 static void
 setup_dp(X509 *x, DIST_POINT *dp)
@@ -690,7 +690,7 @@ X509_check_ca(X509 *x)
 
 	return check_ca(x);
 }
-LCRYPTO_ALIAS(X509_check_ca)
+LCRYPTO_ALIAS(X509_check_ca);
 
 /* Check SSL CA: common checks for SSL client and server */
 static int
@@ -916,7 +916,7 @@ X509_check_issued(X509 *issuer, X509 *subject)
 		return X509_V_ERR_KEYUSAGE_NO_CERTSIGN;
 	return X509_V_OK;
 }
-LCRYPTO_ALIAS(X509_check_issued)
+LCRYPTO_ALIAS(X509_check_issued);
 
 int
 X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid)
@@ -956,7 +956,7 @@ X509_check_akid(X509 *issuer, AUTHORITY_KEYID *akid)
 	}
 	return X509_V_OK;
 }
-LCRYPTO_ALIAS(X509_check_akid)
+LCRYPTO_ALIAS(X509_check_akid);
 
 uint32_t
 X509_get_extension_flags(X509 *x)
@@ -967,7 +967,7 @@ X509_get_extension_flags(X509 *x)
 
 	return x->ex_flags;
 }
-LCRYPTO_ALIAS(X509_get_extension_flags)
+LCRYPTO_ALIAS(X509_get_extension_flags);
 
 uint32_t
 X509_get_key_usage(X509 *x)
@@ -981,7 +981,7 @@ X509_get_key_usage(X509 *x)
 
 	return UINT32_MAX;
 }
-LCRYPTO_ALIAS(X509_get_key_usage)
+LCRYPTO_ALIAS(X509_get_key_usage);
 
 uint32_t
 X509_get_extended_key_usage(X509 *x)
@@ -995,4 +995,4 @@ X509_get_extended_key_usage(X509 *x)
 
 	return UINT32_MAX;
 }
-LCRYPTO_ALIAS(X509_get_extended_key_usage)
+LCRYPTO_ALIAS(X509_get_extended_key_usage);
diff --git a/lib/libcrypto/x509/x509_r2x.c b/lib/libcrypto/x509/x509_r2x.c
index a8ffbdc65bb..99c423d8c99 100644
--- a/lib/libcrypto/x509/x509_r2x.c
+++ b/lib/libcrypto/x509/x509_r2x.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_r2x.c,v 1.15 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_r2x.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -116,4 +116,4 @@ err:
 	X509_free(ret);
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_REQ_to_X509)
+LCRYPTO_ALIAS(X509_REQ_to_X509);
diff --git a/lib/libcrypto/x509/x509_req.c b/lib/libcrypto/x509/x509_req.c
index 32415979e9f..0fea7e68b43 100644
--- a/lib/libcrypto/x509/x509_req.c
+++ b/lib/libcrypto/x509/x509_req.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_req.c,v 1.31 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_req.c,v 1.32 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -115,7 +115,7 @@ err:
 	X509_REQ_free(ret);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_to_X509_REQ)
+LCRYPTO_ALIAS(X509_to_X509_REQ);
 
 EVP_PKEY *
 X509_REQ_get_pubkey(X509_REQ *req)
@@ -124,7 +124,7 @@ X509_REQ_get_pubkey(X509_REQ *req)
 		return (NULL);
 	return (X509_PUBKEY_get(req->req_info->pubkey));
 }
-LCRYPTO_ALIAS(X509_REQ_get_pubkey)
+LCRYPTO_ALIAS(X509_REQ_get_pubkey);
 
 EVP_PKEY *
 X509_REQ_get0_pubkey(X509_REQ *req)
@@ -133,7 +133,7 @@ X509_REQ_get0_pubkey(X509_REQ *req)
 		return NULL;
 	return X509_PUBKEY_get0(req->req_info->pubkey);
 }
-LCRYPTO_ALIAS(X509_REQ_get0_pubkey)
+LCRYPTO_ALIAS(X509_REQ_get0_pubkey);
 
 int
 X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
@@ -173,7 +173,7 @@ X509_REQ_check_private_key(X509_REQ *x, EVP_PKEY *k)
 
 	return (ok);
 }
-LCRYPTO_ALIAS(X509_REQ_check_private_key)
+LCRYPTO_ALIAS(X509_REQ_check_private_key);
 
 /* It seems several organisations had the same idea of including a list of
  * extensions in a certificate request. There are at least two OIDs that are
@@ -197,21 +197,21 @@ X509_REQ_extension_nid(int req_nid)
 			return 1;
 	}
 }
-LCRYPTO_ALIAS(X509_REQ_extension_nid)
+LCRYPTO_ALIAS(X509_REQ_extension_nid);
 
 int *
 X509_REQ_get_extension_nids(void)
 {
 	return ext_nids;
 }
-LCRYPTO_ALIAS(X509_REQ_get_extension_nids)
+LCRYPTO_ALIAS(X509_REQ_get_extension_nids);
 
 void
 X509_REQ_set_extension_nids(int *nids)
 {
 	ext_nids = nids;
 }
-LCRYPTO_ALIAS(X509_REQ_set_extension_nids)
+LCRYPTO_ALIAS(X509_REQ_set_extension_nids);
 
 STACK_OF(X509_EXTENSION) *
 X509_REQ_get_extensions(X509_REQ *req)
@@ -238,7 +238,7 @@ X509_REQ_get_extensions(X509_REQ *req)
 	p = ext->value.sequence->data;
 	return d2i_X509_EXTENSIONS(NULL, &p, ext->value.sequence->length);
 }
-LCRYPTO_ALIAS(X509_REQ_get_extensions)
+LCRYPTO_ALIAS(X509_REQ_get_extensions);
 
 /*
  * Add a STACK_OF extensions to a certificate request: allow alternative OIDs
@@ -262,7 +262,7 @@ X509_REQ_add_extensions_nid(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts,
 
 	return rv;
 }
-LCRYPTO_ALIAS(X509_REQ_add_extensions_nid)
+LCRYPTO_ALIAS(X509_REQ_add_extensions_nid);
 
 /* This is the normal usage: use the "official" OID */
 int
@@ -270,7 +270,7 @@ X509_REQ_add_extensions(X509_REQ *req, STACK_OF(X509_EXTENSION) *exts)
 {
 	return X509_REQ_add_extensions_nid(req, exts, NID_ext_req);
 }
-LCRYPTO_ALIAS(X509_REQ_add_extensions)
+LCRYPTO_ALIAS(X509_REQ_add_extensions);
 
 /* Request attribute functions */
 
@@ -279,14 +279,14 @@ X509_REQ_get_attr_count(const X509_REQ *req)
 {
 	return X509at_get_attr_count(req->req_info->attributes);
 }
-LCRYPTO_ALIAS(X509_REQ_get_attr_count)
+LCRYPTO_ALIAS(X509_REQ_get_attr_count);
 
 int
 X509_REQ_get_attr_by_NID(const X509_REQ *req, int nid, int lastpos)
 {
 	return X509at_get_attr_by_NID(req->req_info->attributes, nid, lastpos);
 }
-LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID)
+LCRYPTO_ALIAS(X509_REQ_get_attr_by_NID);
 
 int
 X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
@@ -294,21 +294,21 @@ X509_REQ_get_attr_by_OBJ(const X509_REQ *req, const ASN1_OBJECT *obj,
 {
 	return X509at_get_attr_by_OBJ(req->req_info->attributes, obj, lastpos);
 }
-LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ)
+LCRYPTO_ALIAS(X509_REQ_get_attr_by_OBJ);
 
 X509_ATTRIBUTE *
 X509_REQ_get_attr(const X509_REQ *req, int loc)
 {
 	return X509at_get_attr(req->req_info->attributes, loc);
 }
-LCRYPTO_ALIAS(X509_REQ_get_attr)
+LCRYPTO_ALIAS(X509_REQ_get_attr);
 
 X509_ATTRIBUTE *
 X509_REQ_delete_attr(X509_REQ *req, int loc)
 {
 	return X509at_delete_attr(req->req_info->attributes, loc);
 }
-LCRYPTO_ALIAS(X509_REQ_delete_attr)
+LCRYPTO_ALIAS(X509_REQ_delete_attr);
 
 int
 X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
@@ -317,7 +317,7 @@ X509_REQ_add1_attr(X509_REQ *req, X509_ATTRIBUTE *attr)
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_REQ_add1_attr)
+LCRYPTO_ALIAS(X509_REQ_add1_attr);
 
 int
 X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type,
@@ -328,7 +328,7 @@ X509_REQ_add1_attr_by_OBJ(X509_REQ *req, const ASN1_OBJECT *obj, int type,
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ)
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_OBJ);
 
 int
 X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type,
@@ -339,7 +339,7 @@ X509_REQ_add1_attr_by_NID(X509_REQ *req, int nid, int type,
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID)
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_NID);
 
 int
 X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type,
@@ -350,7 +350,7 @@ X509_REQ_add1_attr_by_txt(X509_REQ *req, const char *attrname, int type,
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt)
+LCRYPTO_ALIAS(X509_REQ_add1_attr_by_txt);
 
 int
 i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp)
@@ -358,4 +358,4 @@ i2d_re_X509_REQ_tbs(X509_REQ *req, unsigned char **pp)
 	req->req_info->enc.modified = 1;
 	return i2d_X509_REQ_INFO(req->req_info, pp);
 }
-LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs)
+LCRYPTO_ALIAS(i2d_re_X509_REQ_tbs);
diff --git a/lib/libcrypto/x509/x509_set.c b/lib/libcrypto/x509/x509_set.c
index f07f0ec5f25..e65ffb3b4de 100644
--- a/lib/libcrypto/x509/x509_set.c
+++ b/lib/libcrypto/x509/x509_set.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_set.c,v 1.22 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_set.c,v 1.23 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -70,14 +70,14 @@ X509_get0_extensions(const X509 *x)
 {
 	return x->cert_info->extensions;
 }
-LCRYPTO_ALIAS(X509_get0_extensions)
+LCRYPTO_ALIAS(X509_get0_extensions);
 
 const X509_ALGOR *
 X509_get0_tbs_sigalg(const X509 *x)
 {
 	return x->cert_info->signature;
 }
-LCRYPTO_ALIAS(X509_get0_tbs_sigalg)
+LCRYPTO_ALIAS(X509_get0_tbs_sigalg);
 
 int
 X509_set_version(X509 *x, long version)
@@ -90,14 +90,14 @@ X509_set_version(X509 *x, long version)
 	}
 	return (ASN1_INTEGER_set(x->cert_info->version, version));
 }
-LCRYPTO_ALIAS(X509_set_version)
+LCRYPTO_ALIAS(X509_set_version);
 
 long
 X509_get_version(const X509 *x)
 {
 	return ASN1_INTEGER_get(x->cert_info->version);
 }
-LCRYPTO_ALIAS(X509_get_version)
+LCRYPTO_ALIAS(X509_get_version);
 
 int
 X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
@@ -116,7 +116,7 @@ X509_set_serialNumber(X509 *x, ASN1_INTEGER *serial)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_set_serialNumber)
+LCRYPTO_ALIAS(X509_set_serialNumber);
 
 int
 X509_set_issuer_name(X509 *x, X509_NAME *name)
@@ -125,7 +125,7 @@ X509_set_issuer_name(X509 *x, X509_NAME *name)
 		return (0);
 	return (X509_NAME_set(&x->cert_info->issuer, name));
 }
-LCRYPTO_ALIAS(X509_set_issuer_name)
+LCRYPTO_ALIAS(X509_set_issuer_name);
 
 int
 X509_set_subject_name(X509 *x, X509_NAME *name)
@@ -134,14 +134,14 @@ X509_set_subject_name(X509 *x, X509_NAME *name)
 		return (0);
 	return (X509_NAME_set(&x->cert_info->subject, name));
 }
-LCRYPTO_ALIAS(X509_set_subject_name)
+LCRYPTO_ALIAS(X509_set_subject_name);
 
 const ASN1_TIME *
 X509_get0_notBefore(const X509 *x)
 {
 	return X509_getm_notBefore(x);
 }
-LCRYPTO_ALIAS(X509_get0_notBefore)
+LCRYPTO_ALIAS(X509_get0_notBefore);
 
 ASN1_TIME *
 X509_getm_notBefore(const X509 *x)
@@ -150,7 +150,7 @@ X509_getm_notBefore(const X509 *x)
 		return (NULL);
 	return x->cert_info->validity->notBefore;
 }
-LCRYPTO_ALIAS(X509_getm_notBefore)
+LCRYPTO_ALIAS(X509_getm_notBefore);
 
 int
 X509_set_notBefore(X509 *x, const ASN1_TIME *tm)
@@ -169,21 +169,21 @@ X509_set_notBefore(X509 *x, const ASN1_TIME *tm)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_set_notBefore)
+LCRYPTO_ALIAS(X509_set_notBefore);
 
 int
 X509_set1_notBefore(X509 *x, const ASN1_TIME *tm)
 {
 	return X509_set_notBefore(x, tm);
 }
-LCRYPTO_ALIAS(X509_set1_notBefore)
+LCRYPTO_ALIAS(X509_set1_notBefore);
 
 const ASN1_TIME *
 X509_get0_notAfter(const X509 *x)
 {
 	return X509_getm_notAfter(x);
 }
-LCRYPTO_ALIAS(X509_get0_notAfter)
+LCRYPTO_ALIAS(X509_get0_notAfter);
 
 ASN1_TIME *
 X509_getm_notAfter(const X509 *x)
@@ -192,7 +192,7 @@ X509_getm_notAfter(const X509 *x)
 		return (NULL);
 	return x->cert_info->validity->notAfter;
 }
-LCRYPTO_ALIAS(X509_getm_notAfter)
+LCRYPTO_ALIAS(X509_getm_notAfter);
 
 int
 X509_set_notAfter(X509 *x, const ASN1_TIME *tm)
@@ -211,14 +211,14 @@ X509_set_notAfter(X509 *x, const ASN1_TIME *tm)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_set_notAfter)
+LCRYPTO_ALIAS(X509_set_notAfter);
 
 int
 X509_set1_notAfter(X509 *x, const ASN1_TIME *tm)
 {
 	return X509_set_notAfter(x, tm);
 }
-LCRYPTO_ALIAS(X509_set1_notAfter)
+LCRYPTO_ALIAS(X509_set1_notAfter);
 
 int
 X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
@@ -227,18 +227,18 @@ X509_set_pubkey(X509 *x, EVP_PKEY *pkey)
 		return (0);
 	return (X509_PUBKEY_set(&(x->cert_info->key), pkey));
 }
-LCRYPTO_ALIAS(X509_set_pubkey)
+LCRYPTO_ALIAS(X509_set_pubkey);
 
 int
 X509_get_signature_type(const X509 *x)
 {
 	return EVP_PKEY_type(OBJ_obj2nid(x->sig_alg->algorithm));
 }
-LCRYPTO_ALIAS(X509_get_signature_type)
+LCRYPTO_ALIAS(X509_get_signature_type);
 
 X509_PUBKEY *
 X509_get_X509_PUBKEY(const X509 *x)
 {
 	return x->cert_info->key;
 }
-LCRYPTO_ALIAS(X509_get_X509_PUBKEY)
+LCRYPTO_ALIAS(X509_get_X509_PUBKEY);
diff --git a/lib/libcrypto/x509/x509_skey.c b/lib/libcrypto/x509/x509_skey.c
index d4212a64a15..245ba515866 100644
--- a/lib/libcrypto/x509/x509_skey.c
+++ b/lib/libcrypto/x509/x509_skey.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_skey.c,v 1.4 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_skey.c,v 1.5 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -89,7 +89,7 @@ i2s_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, const ASN1_OCTET_STRING *oct)
 {
 	return hex_to_string(oct->data, oct->length);
 }
-LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING)
+LCRYPTO_ALIAS(i2s_ASN1_OCTET_STRING);
 
 ASN1_OCTET_STRING *
 s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
@@ -112,7 +112,7 @@ s2i_ASN1_OCTET_STRING(X509V3_EXT_METHOD *method, X509V3_CTX *ctx,
 
 	return oct;
 }
-LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING)
+LCRYPTO_ALIAS(s2i_ASN1_OCTET_STRING);
 
 static ASN1_OCTET_STRING *
 s2i_skey_id(X509V3_EXT_METHOD *method, X509V3_CTX *ctx, char *str)
diff --git a/lib/libcrypto/x509/x509_sxnet.c b/lib/libcrypto/x509/x509_sxnet.c
index 9c66a6b7692..77c792d2270 100644
--- a/lib/libcrypto/x509/x509_sxnet.c
+++ b/lib/libcrypto/x509/x509_sxnet.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_sxnet.c,v 1.2 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509_sxnet.c,v 1.3 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -131,28 +131,28 @@ d2i_SXNETID(SXNETID **a, const unsigned char **in, long len)
 	return (SXNETID *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &SXNETID_it);
 }
-LCRYPTO_ALIAS(d2i_SXNETID)
+LCRYPTO_ALIAS(d2i_SXNETID);
 
 int
 i2d_SXNETID(SXNETID *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNETID_it);
 }
-LCRYPTO_ALIAS(i2d_SXNETID)
+LCRYPTO_ALIAS(i2d_SXNETID);
 
 SXNETID *
 SXNETID_new(void)
 {
 	return (SXNETID *)ASN1_item_new(&SXNETID_it);
 }
-LCRYPTO_ALIAS(SXNETID_new)
+LCRYPTO_ALIAS(SXNETID_new);
 
 void
 SXNETID_free(SXNETID *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &SXNETID_it);
 }
-LCRYPTO_ALIAS(SXNETID_free)
+LCRYPTO_ALIAS(SXNETID_free);
 
 static const ASN1_TEMPLATE SXNET_seq_tt[] = {
 	{
@@ -188,28 +188,28 @@ d2i_SXNET(SXNET **a, const unsigned char **in, long len)
 	return (SXNET *)ASN1_item_d2i((ASN1_VALUE **)a, in, len,
 	    &SXNET_it);
 }
-LCRYPTO_ALIAS(d2i_SXNET)
+LCRYPTO_ALIAS(d2i_SXNET);
 
 int
 i2d_SXNET(SXNET *a, unsigned char **out)
 {
 	return ASN1_item_i2d((ASN1_VALUE *)a, out, &SXNET_it);
 }
-LCRYPTO_ALIAS(i2d_SXNET)
+LCRYPTO_ALIAS(i2d_SXNET);
 
 SXNET *
 SXNET_new(void)
 {
 	return (SXNET *)ASN1_item_new(&SXNET_it);
 }
-LCRYPTO_ALIAS(SXNET_new)
+LCRYPTO_ALIAS(SXNET_new);
 
 void
 SXNET_free(SXNET *a)
 {
 	ASN1_item_free((ASN1_VALUE *)a, &SXNET_it);
 }
-LCRYPTO_ALIAS(SXNET_free)
+LCRYPTO_ALIAS(SXNET_free);
 
 static int
 sxnet_i2r(X509V3_EXT_METHOD *method, SXNET *sx, BIO *out, int indent)
@@ -271,7 +271,7 @@ SXNET_add_id_asc(SXNET **psx, const char *zone, const char *user, int userlen)
 	}
 	return SXNET_add_id_INTEGER(psx, izone, user, userlen);
 }
-LCRYPTO_ALIAS(SXNET_add_id_asc)
+LCRYPTO_ALIAS(SXNET_add_id_asc);
 
 /* Add an id given the zone as an unsigned long */
 
@@ -289,7 +289,7 @@ SXNET_add_id_ulong(SXNET **psx, unsigned long lzone, const char *user,
 	}
 	return SXNET_add_id_INTEGER(psx, izone, user, userlen);
 }
-LCRYPTO_ALIAS(SXNET_add_id_ulong)
+LCRYPTO_ALIAS(SXNET_add_id_ulong);
 
 /* Add an id given the zone as an ASN1_INTEGER.
  * Note this version uses the passed integer and doesn't make a copy so don't
@@ -345,7 +345,7 @@ err:
 	*psx = NULL;
 	return 0;
 }
-LCRYPTO_ALIAS(SXNET_add_id_INTEGER)
+LCRYPTO_ALIAS(SXNET_add_id_INTEGER);
 
 ASN1_OCTET_STRING *
 SXNET_get_id_asc(SXNET *sx, const char *zone)
@@ -361,7 +361,7 @@ SXNET_get_id_asc(SXNET *sx, const char *zone)
 	ASN1_INTEGER_free(izone);
 	return oct;
 }
-LCRYPTO_ALIAS(SXNET_get_id_asc)
+LCRYPTO_ALIAS(SXNET_get_id_asc);
 
 ASN1_OCTET_STRING *
 SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
@@ -379,7 +379,7 @@ SXNET_get_id_ulong(SXNET *sx, unsigned long lzone)
 	ASN1_INTEGER_free(izone);
 	return oct;
 }
-LCRYPTO_ALIAS(SXNET_get_id_ulong)
+LCRYPTO_ALIAS(SXNET_get_id_ulong);
 
 ASN1_OCTET_STRING *
 SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
@@ -394,4 +394,4 @@ SXNET_get_id_INTEGER(SXNET *sx, ASN1_INTEGER *zone)
 	}
 	return NULL;
 }
-LCRYPTO_ALIAS(SXNET_get_id_INTEGER)
+LCRYPTO_ALIAS(SXNET_get_id_INTEGER);
diff --git a/lib/libcrypto/x509/x509_trs.c b/lib/libcrypto/x509/x509_trs.c
index 10995801b18..e3265918a43 100644
--- a/lib/libcrypto/x509/x509_trs.c
+++ b/lib/libcrypto/x509/x509_trs.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_trs.c,v 1.30 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_trs.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -109,7 +109,7 @@ int
 	default_trust = trust;
 	return oldtrust;
 }
-LCRYPTO_ALIAS(X509_TRUST_set_default)
+LCRYPTO_ALIAS(X509_TRUST_set_default);
 
 int
 X509_check_trust(X509 *x, int id, int flags)
@@ -141,7 +141,7 @@ X509_check_trust(X509 *x, int id, int flags)
 	pt = X509_TRUST_get0(idx);
 	return pt->check_trust(pt, x, flags);
 }
-LCRYPTO_ALIAS(X509_check_trust)
+LCRYPTO_ALIAS(X509_check_trust);
 
 int
 X509_TRUST_get_count(void)
@@ -150,7 +150,7 @@ X509_TRUST_get_count(void)
 		return X509_TRUST_COUNT;
 	return sk_X509_TRUST_num(trtable) + X509_TRUST_COUNT;
 }
-LCRYPTO_ALIAS(X509_TRUST_get_count)
+LCRYPTO_ALIAS(X509_TRUST_get_count);
 
 X509_TRUST *
 X509_TRUST_get0(int idx)
@@ -161,7 +161,7 @@ X509_TRUST_get0(int idx)
 		return trstandard + idx;
 	return sk_X509_TRUST_value(trtable, idx - X509_TRUST_COUNT);
 }
-LCRYPTO_ALIAS(X509_TRUST_get0)
+LCRYPTO_ALIAS(X509_TRUST_get0);
 
 int
 X509_TRUST_get_by_id(int id)
@@ -179,7 +179,7 @@ X509_TRUST_get_by_id(int id)
 		return -1;
 	return idx + X509_TRUST_COUNT;
 }
-LCRYPTO_ALIAS(X509_TRUST_get_by_id)
+LCRYPTO_ALIAS(X509_TRUST_get_by_id);
 
 int
 X509_TRUST_set(int *t, int trust)
@@ -191,7 +191,7 @@ X509_TRUST_set(int *t, int trust)
 	*t = trust;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_TRUST_set)
+LCRYPTO_ALIAS(X509_TRUST_set);
 
 int
 X509_TRUST_add(int id, int flags, int (*ck)(X509_TRUST *, X509 *, int),
@@ -257,7 +257,7 @@ err:
 	X509error(ERR_R_MALLOC_FAILURE);
 	return 0;
 }
-LCRYPTO_ALIAS(X509_TRUST_add)
+LCRYPTO_ALIAS(X509_TRUST_add);
 
 static void
 trtable_free(X509_TRUST *p)
@@ -277,28 +277,28 @@ X509_TRUST_cleanup(void)
 	sk_X509_TRUST_pop_free(trtable, trtable_free);
 	trtable = NULL;
 }
-LCRYPTO_ALIAS(X509_TRUST_cleanup)
+LCRYPTO_ALIAS(X509_TRUST_cleanup);
 
 int
 X509_TRUST_get_flags(const X509_TRUST *xp)
 {
 	return xp->flags;
 }
-LCRYPTO_ALIAS(X509_TRUST_get_flags)
+LCRYPTO_ALIAS(X509_TRUST_get_flags);
 
 char *
 X509_TRUST_get0_name(const X509_TRUST *xp)
 {
 	return xp->name;
 }
-LCRYPTO_ALIAS(X509_TRUST_get0_name)
+LCRYPTO_ALIAS(X509_TRUST_get0_name);
 
 int
 X509_TRUST_get_trust(const X509_TRUST *xp)
 {
 	return xp->trust;
 }
-LCRYPTO_ALIAS(X509_TRUST_get_trust)
+LCRYPTO_ALIAS(X509_TRUST_get_trust);
 
 static int
 trust_1oidany(X509_TRUST *trust, X509 *x, int flags)
diff --git a/lib/libcrypto/x509/x509_txt.c b/lib/libcrypto/x509/x509_txt.c
index fb33fd7dc2f..5f5bc5ae84b 100644
--- a/lib/libcrypto/x509/x509_txt.c
+++ b/lib/libcrypto/x509/x509_txt.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_txt.c,v 1.27 2022/11/29 12:23:43 tb Exp $ */
+/* $OpenBSD: x509_txt.c,v 1.28 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -193,4 +193,4 @@ X509_verify_cert_error_string(long n)
 		return "Unknown certificate verification error";
 	}
 }
-LCRYPTO_ALIAS(X509_verify_cert_error_string)
+LCRYPTO_ALIAS(X509_verify_cert_error_string);
diff --git a/lib/libcrypto/x509/x509_utl.c b/lib/libcrypto/x509/x509_utl.c
index aa18efe2c55..ec67ae093cf 100644
--- a/lib/libcrypto/x509/x509_utl.c
+++ b/lib/libcrypto/x509/x509_utl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_utl.c,v 1.5 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509_utl.c,v 1.6 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project.
  */
@@ -117,7 +117,7 @@ X509V3_add_value(const char *name, const char *value,
 	}
 	return 0;
 }
-LCRYPTO_ALIAS(X509V3_add_value)
+LCRYPTO_ALIAS(X509V3_add_value);
 
 int
 X509V3_add_value_uchar(const char *name, const unsigned char *value,
@@ -125,7 +125,7 @@ X509V3_add_value_uchar(const char *name, const unsigned char *value,
 {
 	return X509V3_add_value(name, (const char *)value, extlist);
 }
-LCRYPTO_ALIAS(X509V3_add_value_uchar)
+LCRYPTO_ALIAS(X509V3_add_value_uchar);
 
 /* Free function for STACK_OF(CONF_VALUE) */
 
@@ -139,7 +139,7 @@ X509V3_conf_free(CONF_VALUE *conf)
 	free(conf->section);
 	free(conf);
 }
-LCRYPTO_ALIAS(X509V3_conf_free)
+LCRYPTO_ALIAS(X509V3_conf_free);
 
 int
 X509V3_add_value_bool(const char *name, int asn1_bool,
@@ -149,7 +149,7 @@ X509V3_add_value_bool(const char *name, int asn1_bool,
 		return X509V3_add_value(name, "TRUE", extlist);
 	return X509V3_add_value(name, "FALSE", extlist);
 }
-LCRYPTO_ALIAS(X509V3_add_value_bool)
+LCRYPTO_ALIAS(X509V3_add_value_bool);
 
 int
 X509V3_add_value_bool_nf(const char *name, int asn1_bool,
@@ -159,7 +159,7 @@ X509V3_add_value_bool_nf(const char *name, int asn1_bool,
 		return X509V3_add_value(name, "TRUE", extlist);
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_add_value_bool_nf)
+LCRYPTO_ALIAS(X509V3_add_value_bool_nf);
 
 char *
 bn_to_string(const BIGNUM *bn)
@@ -202,7 +202,7 @@ i2s_ASN1_ENUMERATED(X509V3_EXT_METHOD *method, const ASN1_ENUMERATED *a)
 	BN_free(bntmp);
 	return strtmp;
 }
-LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED)
+LCRYPTO_ALIAS(i2s_ASN1_ENUMERATED);
 
 char *
 i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a)
@@ -218,7 +218,7 @@ i2s_ASN1_INTEGER(X509V3_EXT_METHOD *method, const ASN1_INTEGER *a)
 	BN_free(bntmp);
 	return strtmp;
 }
-LCRYPTO_ALIAS(i2s_ASN1_INTEGER)
+LCRYPTO_ALIAS(i2s_ASN1_INTEGER);
 
 ASN1_INTEGER *
 s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value)
@@ -269,7 +269,7 @@ s2i_ASN1_INTEGER(X509V3_EXT_METHOD *method, const char *value)
 		aint->type |= V_ASN1_NEG;
 	return aint;
 }
-LCRYPTO_ALIAS(s2i_ASN1_INTEGER)
+LCRYPTO_ALIAS(s2i_ASN1_INTEGER);
 
 int
 X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
@@ -286,7 +286,7 @@ X509V3_add_value_int(const char *name, const ASN1_INTEGER *aint,
 	free(strtmp);
 	return ret;
 }
-LCRYPTO_ALIAS(X509V3_add_value_int)
+LCRYPTO_ALIAS(X509V3_add_value_int);
 
 int
 X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool)
@@ -312,7 +312,7 @@ X509V3_get_value_bool(const CONF_VALUE *value, int *asn1_bool)
 	X509V3_conf_err(value);
 	return 0;
 }
-LCRYPTO_ALIAS(X509V3_get_value_bool)
+LCRYPTO_ALIAS(X509V3_get_value_bool);
 
 int
 X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint)
@@ -326,7 +326,7 @@ X509V3_get_value_int(const CONF_VALUE *value, ASN1_INTEGER **aint)
 	*aint = itmp;
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_get_value_int)
+LCRYPTO_ALIAS(X509V3_get_value_int);
 
 #define HDR_NAME	1
 #define HDR_VALUE	2
@@ -418,7 +418,7 @@ X509V3_parse_list(const char *line)
 	return NULL;
 
 }
-LCRYPTO_ALIAS(X509V3_parse_list)
+LCRYPTO_ALIAS(X509V3_parse_list);
 
 /* Delete leading and trailing spaces from a string */
 static char *
@@ -470,7 +470,7 @@ hex_to_string(const unsigned char *buffer, long len)
 	q[-1] = 0;
 	return tmp;
 }
-LCRYPTO_ALIAS(hex_to_string)
+LCRYPTO_ALIAS(hex_to_string);
 
 /* Give a string of hex digits convert to
  * a buffer
@@ -532,7 +532,7 @@ string_to_hex(const char *str, long *len)
 	X509V3error(X509V3_R_ILLEGAL_HEX_DIGIT);
 	return NULL;
 }
-LCRYPTO_ALIAS(string_to_hex)
+LCRYPTO_ALIAS(string_to_hex);
 
 /* V2I name comparison function: returns zero if 'name' matches
  * cmp or cmp.*
@@ -570,7 +570,7 @@ X509_get1_email(X509 *x)
 	sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_get1_email)
+LCRYPTO_ALIAS(X509_get1_email);
 
 STACK_OF(OPENSSL_STRING) *
 X509_get1_ocsp(X509 *x)
@@ -595,7 +595,7 @@ X509_get1_ocsp(X509 *x)
 	AUTHORITY_INFO_ACCESS_free(info);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_get1_ocsp)
+LCRYPTO_ALIAS(X509_get1_ocsp);
 
 STACK_OF(OPENSSL_STRING) *
 X509_REQ_get1_email(X509_REQ *x)
@@ -611,7 +611,7 @@ X509_REQ_get1_email(X509_REQ *x)
 	sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_REQ_get1_email)
+LCRYPTO_ALIAS(X509_REQ_get1_email);
 
 
 static STACK_OF(OPENSSL_STRING) *
@@ -681,7 +681,7 @@ X509_email_free(STACK_OF(OPENSSL_STRING) *sk)
 {
 	sk_OPENSSL_STRING_pop_free(sk, str_free);
 }
-LCRYPTO_ALIAS(X509_email_free)
+LCRYPTO_ALIAS(X509_email_free);
 
 typedef int (*equal_fn)(const unsigned char *pattern, size_t pattern_len,
     const unsigned char *subject, size_t subject_len, unsigned int flags);
@@ -1083,7 +1083,7 @@ X509_check_host(X509 *x, const char *chk, size_t chklen, unsigned int flags,
 		return -2;
 	return do_x509_check(x, chk, chklen, flags, GEN_DNS, peername);
 }
-LCRYPTO_ALIAS(X509_check_host)
+LCRYPTO_ALIAS(X509_check_host);
 
 int
 X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags)
@@ -1096,7 +1096,7 @@ X509_check_email(X509 *x, const char *chk, size_t chklen, unsigned int flags)
 		return -2;
 	return do_x509_check(x, chk, chklen, flags, GEN_EMAIL, NULL);
 }
-LCRYPTO_ALIAS(X509_check_email)
+LCRYPTO_ALIAS(X509_check_email);
 
 int
 X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
@@ -1106,7 +1106,7 @@ X509_check_ip(X509 *x, const unsigned char *chk, size_t chklen,
 		return -2;
 	return do_x509_check(x, (char *)chk, chklen, flags, GEN_IPADD, NULL);
 }
-LCRYPTO_ALIAS(X509_check_ip)
+LCRYPTO_ALIAS(X509_check_ip);
 
 int
 X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
@@ -1121,7 +1121,7 @@ X509_check_ip_asc(X509 *x, const char *ipasc, unsigned int flags)
 		return -2;
 	return do_x509_check(x, (char *)ipout, iplen, flags, GEN_IPADD, NULL);
 }
-LCRYPTO_ALIAS(X509_check_ip_asc)
+LCRYPTO_ALIAS(X509_check_ip_asc);
 
 /* Convert IP addresses both IPv4 and IPv6 into an
  * OCTET STRING compatible with RFC3280.
@@ -1150,7 +1150,7 @@ a2i_IPADDRESS(const char *ipasc)
 	}
 	return ret;
 }
-LCRYPTO_ALIAS(a2i_IPADDRESS)
+LCRYPTO_ALIAS(a2i_IPADDRESS);
 
 ASN1_OCTET_STRING *
 a2i_IPADDRESS_NC(const char *ipasc)
@@ -1196,7 +1196,7 @@ a2i_IPADDRESS_NC(const char *ipasc)
 		ASN1_OCTET_STRING_free(ret);
 	return NULL;
 }
-LCRYPTO_ALIAS(a2i_IPADDRESS_NC)
+LCRYPTO_ALIAS(a2i_IPADDRESS_NC);
 
 
 int
@@ -1214,7 +1214,7 @@ a2i_ipadd(unsigned char *ipout, const char *ipasc)
 		return 4;
 	}
 }
-LCRYPTO_ALIAS(a2i_ipadd)
+LCRYPTO_ALIAS(a2i_ipadd);
 
 static int
 ipv4_from_asc(unsigned char *v4, const char *in)
@@ -1411,4 +1411,4 @@ X509V3_NAME_from_section(X509_NAME *nm, STACK_OF(CONF_VALUE)*dn_sk,
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509V3_NAME_from_section)
+LCRYPTO_ALIAS(X509V3_NAME_from_section);
diff --git a/lib/libcrypto/x509/x509_v3.c b/lib/libcrypto/x509/x509_v3.c
index 27f670c450f..8dddb463ce0 100644
--- a/lib/libcrypto/x509/x509_v3.c
+++ b/lib/libcrypto/x509/x509_v3.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_v3.c,v 1.20 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_v3.c,v 1.21 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -75,7 +75,7 @@ X509v3_get_ext_count(const STACK_OF(X509_EXTENSION) *x)
 		return (0);
 	return (sk_X509_EXTENSION_num(x));
 }
-LCRYPTO_ALIAS(X509v3_get_ext_count)
+LCRYPTO_ALIAS(X509v3_get_ext_count);
 
 int
 X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos)
@@ -87,7 +87,7 @@ X509v3_get_ext_by_NID(const STACK_OF(X509_EXTENSION) *x, int nid, int lastpos)
 		return (-2);
 	return (X509v3_get_ext_by_OBJ(x, obj, lastpos));
 }
-LCRYPTO_ALIAS(X509v3_get_ext_by_NID)
+LCRYPTO_ALIAS(X509v3_get_ext_by_NID);
 
 int
 X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
@@ -109,7 +109,7 @@ X509v3_get_ext_by_OBJ(const STACK_OF(X509_EXTENSION) *sk,
 	}
 	return (-1);
 }
-LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ)
+LCRYPTO_ALIAS(X509v3_get_ext_by_OBJ);
 
 int
 X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
@@ -132,7 +132,7 @@ X509v3_get_ext_by_critical(const STACK_OF(X509_EXTENSION) *sk, int crit,
 	}
 	return (-1);
 }
-LCRYPTO_ALIAS(X509v3_get_ext_by_critical)
+LCRYPTO_ALIAS(X509v3_get_ext_by_critical);
 
 X509_EXTENSION *
 X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc)
@@ -142,7 +142,7 @@ X509v3_get_ext(const STACK_OF(X509_EXTENSION) *x, int loc)
 	else
 		return sk_X509_EXTENSION_value(x, loc);
 }
-LCRYPTO_ALIAS(X509v3_get_ext)
+LCRYPTO_ALIAS(X509v3_get_ext);
 
 X509_EXTENSION *
 X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc)
@@ -154,7 +154,7 @@ X509v3_delete_ext(STACK_OF(X509_EXTENSION) *x, int loc)
 	ret = sk_X509_EXTENSION_delete(x, loc);
 	return (ret);
 }
-LCRYPTO_ALIAS(X509v3_delete_ext)
+LCRYPTO_ALIAS(X509v3_delete_ext);
 
 STACK_OF(X509_EXTENSION) *
 X509v3_add_ext(STACK_OF(X509_EXTENSION) **x, X509_EXTENSION *ex, int loc)
@@ -197,7 +197,7 @@ err2:
 		sk_X509_EXTENSION_free(sk);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509v3_add_ext)
+LCRYPTO_ALIAS(X509v3_add_ext);
 
 X509_EXTENSION *
 X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit,
@@ -216,7 +216,7 @@ X509_EXTENSION_create_by_NID(X509_EXTENSION **ex, int nid, int crit,
 		ASN1_OBJECT_free(obj);
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID)
+LCRYPTO_ALIAS(X509_EXTENSION_create_by_NID);
 
 X509_EXTENSION *
 X509_EXTENSION_create_by_OBJ(X509_EXTENSION **ex, const ASN1_OBJECT *obj,
@@ -248,7 +248,7 @@ err:
 		X509_EXTENSION_free(ret);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ)
+LCRYPTO_ALIAS(X509_EXTENSION_create_by_OBJ);
 
 int
 X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj)
@@ -259,7 +259,7 @@ X509_EXTENSION_set_object(X509_EXTENSION *ex, const ASN1_OBJECT *obj)
 	ex->object = OBJ_dup(obj);
 	return ex->object != NULL;
 }
-LCRYPTO_ALIAS(X509_EXTENSION_set_object)
+LCRYPTO_ALIAS(X509_EXTENSION_set_object);
 
 int
 X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
@@ -269,7 +269,7 @@ X509_EXTENSION_set_critical(X509_EXTENSION *ex, int crit)
 	ex->critical = (crit) ? 0xFF : -1;
 	return (1);
 }
-LCRYPTO_ALIAS(X509_EXTENSION_set_critical)
+LCRYPTO_ALIAS(X509_EXTENSION_set_critical);
 
 int
 X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
@@ -283,7 +283,7 @@ X509_EXTENSION_set_data(X509_EXTENSION *ex, ASN1_OCTET_STRING *data)
 		return (0);
 	return (1);
 }
-LCRYPTO_ALIAS(X509_EXTENSION_set_data)
+LCRYPTO_ALIAS(X509_EXTENSION_set_data);
 
 ASN1_OBJECT *
 X509_EXTENSION_get_object(X509_EXTENSION *ex)
@@ -292,7 +292,7 @@ X509_EXTENSION_get_object(X509_EXTENSION *ex)
 		return (NULL);
 	return (ex->object);
 }
-LCRYPTO_ALIAS(X509_EXTENSION_get_object)
+LCRYPTO_ALIAS(X509_EXTENSION_get_object);
 
 ASN1_OCTET_STRING *
 X509_EXTENSION_get_data(X509_EXTENSION *ex)
@@ -301,7 +301,7 @@ X509_EXTENSION_get_data(X509_EXTENSION *ex)
 		return (NULL);
 	return (ex->value);
 }
-LCRYPTO_ALIAS(X509_EXTENSION_get_data)
+LCRYPTO_ALIAS(X509_EXTENSION_get_data);
 
 int
 X509_EXTENSION_get_critical(const X509_EXTENSION *ex)
@@ -312,4 +312,4 @@ X509_EXTENSION_get_critical(const X509_EXTENSION *ex)
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_EXTENSION_get_critical)
+LCRYPTO_ALIAS(X509_EXTENSION_get_critical);
diff --git a/lib/libcrypto/x509/x509_vfy.c b/lib/libcrypto/x509/x509_vfy.c
index f6c7c21f5f6..8bba7961981 100644
--- a/lib/libcrypto/x509/x509_vfy.c
+++ b/lib/libcrypto/x509/x509_vfy.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_vfy.c,v 1.110 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509_vfy.c,v 1.111 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -668,7 +668,7 @@ X509_verify_cert(X509_STORE_CTX *ctx)
 	/* if we succeed we have a chain in ctx->chain */
 	return (chain_count > 0 && ctx->chain != NULL);
 }
-LCRYPTO_ALIAS(X509_verify_cert)
+LCRYPTO_ALIAS(X509_verify_cert);
 
 /* Given a STACK_OF(X509) find the issuer of cert (if any)
  */
@@ -2012,7 +2012,7 @@ X509_cmp_current_time(const ASN1_TIME *ctm)
 {
 	return X509_cmp_time(ctm, NULL);
 }
-LCRYPTO_ALIAS(X509_cmp_current_time)
+LCRYPTO_ALIAS(X509_cmp_current_time);
 
 /*
  * Compare a possibly unvalidated ASN1_TIME string against a time_t
@@ -2052,7 +2052,7 @@ X509_cmp_time(const ASN1_TIME *ctm, time_t *cmp_time)
 {
 	return X509_cmp_time_internal(ctm, cmp_time, 0);
 }
-LCRYPTO_ALIAS(X509_cmp_time)
+LCRYPTO_ALIAS(X509_cmp_time);
 
 
 ASN1_TIME *
@@ -2060,14 +2060,14 @@ X509_gmtime_adj(ASN1_TIME *s, long adj)
 {
 	return X509_time_adj(s, adj, NULL);
 }
-LCRYPTO_ALIAS(X509_gmtime_adj)
+LCRYPTO_ALIAS(X509_gmtime_adj);
 
 ASN1_TIME *
 X509_time_adj(ASN1_TIME *s, long offset_sec, time_t *in_time)
 {
 	return X509_time_adj_ex(s, 0, offset_sec, in_time);
 }
-LCRYPTO_ALIAS(X509_time_adj)
+LCRYPTO_ALIAS(X509_time_adj);
 
 ASN1_TIME *
 X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
@@ -2080,7 +2080,7 @@ X509_time_adj_ex(ASN1_TIME *s, int offset_day, long offset_sec, time_t *in_time)
 
 	return ASN1_TIME_adj(s, t, offset_day, offset_sec);
 }
-LCRYPTO_ALIAS(X509_time_adj_ex)
+LCRYPTO_ALIAS(X509_time_adj_ex);
 
 int
 X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
@@ -2120,7 +2120,7 @@ X509_get_pubkey_parameters(EVP_PKEY *pkey, STACK_OF(X509) *chain)
 			return 0;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_get_pubkey_parameters)
+LCRYPTO_ALIAS(X509_get_pubkey_parameters);
 
 int
 X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
@@ -2131,77 +2131,77 @@ X509_STORE_CTX_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 	return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_X509_STORE_CTX,
 	    argl, argp, new_func, dup_func, free_func);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_new_index)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_new_index);
 
 int
 X509_STORE_CTX_set_ex_data(X509_STORE_CTX *ctx, int idx, void *data)
 {
 	return CRYPTO_set_ex_data(&ctx->ex_data, idx, data);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_ex_data)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_ex_data);
 
 void *
 X509_STORE_CTX_get_ex_data(X509_STORE_CTX *ctx, int idx)
 {
 	return CRYPTO_get_ex_data(&ctx->ex_data, idx);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_data)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_ex_data);
 
 int
 X509_STORE_CTX_get_error(X509_STORE_CTX *ctx)
 {
 	return ctx->error;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_error)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error);
 
 void
 X509_STORE_CTX_set_error(X509_STORE_CTX *ctx, int err)
 {
 	ctx->error = err;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_error)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error);
 
 int
 X509_STORE_CTX_get_error_depth(X509_STORE_CTX *ctx)
 {
 	return ctx->error_depth;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_error_depth)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_error_depth);
 
 void
 X509_STORE_CTX_set_error_depth(X509_STORE_CTX *ctx, int depth)
 {
 	ctx->error_depth = depth;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_error_depth)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_error_depth);
 
 X509 *
 X509_STORE_CTX_get_current_cert(X509_STORE_CTX *ctx)
 {
 	return ctx->current_cert;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_current_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_current_cert);
 
 void
 X509_STORE_CTX_set_current_cert(X509_STORE_CTX *ctx, X509 *x)
 {
 	ctx->current_cert = x;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_current_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_current_cert);
 
 STACK_OF(X509) *
 X509_STORE_CTX_get_chain(X509_STORE_CTX *ctx)
 {
 	return ctx->chain;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_chain);
 
 STACK_OF(X509) *
 X509_STORE_CTX_get0_chain(X509_STORE_CTX *xs)
 {
 	return xs->chain;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_chain);
 
 STACK_OF(X509) *
 X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
@@ -2218,70 +2218,70 @@ X509_STORE_CTX_get1_chain(X509_STORE_CTX *ctx)
 	}
 	return chain;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get1_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_get1_chain);
 
 X509 *
 X509_STORE_CTX_get0_current_issuer(X509_STORE_CTX *ctx)
 {
 	return ctx->current_issuer;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_issuer)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_issuer);
 
 X509_CRL *
 X509_STORE_CTX_get0_current_crl(X509_STORE_CTX *ctx)
 {
 	return ctx->current_crl;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_crl)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_current_crl);
 
 X509_STORE_CTX *
 X509_STORE_CTX_get0_parent_ctx(X509_STORE_CTX *ctx)
 {
 	return ctx->parent;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_parent_ctx)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_parent_ctx);
 
 X509_STORE *
 X509_STORE_CTX_get0_store(X509_STORE_CTX *xs)
 {
 	return xs->store;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_store)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_store);
 
 void
 X509_STORE_CTX_set_cert(X509_STORE_CTX *ctx, X509 *x)
 {
 	ctx->cert = x;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_cert);
 
 void
 X509_STORE_CTX_set_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
 	ctx->untrusted = sk;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_chain);
 
 void
 X509_STORE_CTX_set0_crls(X509_STORE_CTX *ctx, STACK_OF(X509_CRL) *sk)
 {
 	ctx->crls = sk;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_crls)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_crls);
 
 int
 X509_STORE_CTX_set_purpose(X509_STORE_CTX *ctx, int purpose)
 {
 	return X509_STORE_CTX_purpose_inherit(ctx, 0, purpose, 0);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_purpose)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_purpose);
 
 int
 X509_STORE_CTX_set_trust(X509_STORE_CTX *ctx, int trust)
 {
 	return X509_STORE_CTX_purpose_inherit(ctx, 0, 0, trust);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_trust)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_trust);
 
 /* This function is used to set the X509_STORE_CTX purpose and trust
  * values. This is intended to be used when another structure has its
@@ -2337,7 +2337,7 @@ X509_STORE_CTX_purpose_inherit(X509_STORE_CTX *ctx, int def_purpose,
 		ctx->param->trust = trust;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit)
+LCRYPTO_ALIAS(X509_STORE_CTX_purpose_inherit);
 
 X509_STORE_CTX *
 X509_STORE_CTX_new(void)
@@ -2351,7 +2351,7 @@ X509_STORE_CTX_new(void)
 	}
 	return ctx;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_new)
+LCRYPTO_ALIAS(X509_STORE_CTX_new);
 
 void
 X509_STORE_CTX_free(X509_STORE_CTX *ctx)
@@ -2362,7 +2362,7 @@ X509_STORE_CTX_free(X509_STORE_CTX *ctx)
 	X509_STORE_CTX_cleanup(ctx);
 	free(ctx);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_free)
+LCRYPTO_ALIAS(X509_STORE_CTX_free);
 
 int
 X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
@@ -2484,7 +2484,7 @@ X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
 	}
 	return 1;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_init)
+LCRYPTO_ALIAS(X509_STORE_CTX_init);
 
 /* Set alternative lookup method: just a STACK of trusted certificates.
  * This avoids X509_STORE nastiness where it isn't needed.
@@ -2496,14 +2496,14 @@ X509_STORE_CTX_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 	ctx->other_ctx = sk;
 	ctx->get_issuer = get_issuer_sk;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_trusted_stack)
+LCRYPTO_ALIAS(X509_STORE_CTX_trusted_stack);
 
 void
 X509_STORE_CTX_set0_trusted_stack(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
 	X509_STORE_CTX_trusted_stack(ctx, sk);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_trusted_stack);
 
 void
 X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
@@ -2527,35 +2527,35 @@ X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
 	    ctx, &(ctx->ex_data));
 	memset(&ctx->ex_data, 0, sizeof(CRYPTO_EX_DATA));
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_cleanup)
+LCRYPTO_ALIAS(X509_STORE_CTX_cleanup);
 
 void
 X509_STORE_CTX_set_depth(X509_STORE_CTX *ctx, int depth)
 {
 	X509_VERIFY_PARAM_set_depth(ctx->param, depth);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_depth)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_depth);
 
 void
 X509_STORE_CTX_set_flags(X509_STORE_CTX *ctx, unsigned long flags)
 {
 	X509_VERIFY_PARAM_set_flags(ctx->param, flags);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_flags)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_flags);
 
 void
 X509_STORE_CTX_set_time(X509_STORE_CTX *ctx, unsigned long flags, time_t t)
 {
 	X509_VERIFY_PARAM_set_time(ctx->param, t);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_time)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_time);
 
 int
 (*X509_STORE_CTX_get_verify_cb(X509_STORE_CTX *ctx))(int, X509_STORE_CTX *)
 {
 	return ctx->verify_cb;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify_cb);
 
 void
 X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
@@ -2563,28 +2563,28 @@ X509_STORE_CTX_set_verify_cb(X509_STORE_CTX *ctx,
 {
 	ctx->verify_cb = verify_cb;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_verify_cb)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify_cb);
 
 int
 (*X509_STORE_CTX_get_verify(X509_STORE_CTX *ctx))(X509_STORE_CTX *)
 {
 	return ctx->verify;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_verify)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_verify);
 
 void
 X509_STORE_CTX_set_verify(X509_STORE_CTX *ctx, int (*verify)(X509_STORE_CTX *))
 {
 	ctx->verify = verify;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_verify)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_verify);
 
 X509_STORE_CTX_check_issued_fn
 X509_STORE_get_check_issued(X509_STORE *store)
 {
 	return store->check_issued;
 }
-LCRYPTO_ALIAS(X509_STORE_get_check_issued)
+LCRYPTO_ALIAS(X509_STORE_get_check_issued);
 
 void
 X509_STORE_set_check_issued(X509_STORE *store,
@@ -2592,35 +2592,35 @@ X509_STORE_set_check_issued(X509_STORE *store,
 {
 	store->check_issued = check_issued;
 }
-LCRYPTO_ALIAS(X509_STORE_set_check_issued)
+LCRYPTO_ALIAS(X509_STORE_set_check_issued);
 
 X509_STORE_CTX_check_issued_fn
 X509_STORE_CTX_get_check_issued(X509_STORE_CTX *ctx)
 {
 	return ctx->check_issued;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_check_issued)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_check_issued);
 
 X509 *
 X509_STORE_CTX_get0_cert(X509_STORE_CTX *ctx)
 {
 	return ctx->cert;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_cert)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_cert);
 
 STACK_OF(X509) *
 X509_STORE_CTX_get0_untrusted(X509_STORE_CTX *ctx)
 {
 	return ctx->untrusted;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_untrusted)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_untrusted);
 
 void
 X509_STORE_CTX_set0_untrusted(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 {
 	ctx->untrusted = sk;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_untrusted);
 
 void
 X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
@@ -2628,28 +2628,28 @@ X509_STORE_CTX_set0_verified_chain(X509_STORE_CTX *ctx, STACK_OF(X509) *sk)
 	sk_X509_pop_free(ctx->chain, X509_free);
 	ctx->chain = sk;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_verified_chain)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_verified_chain);
 
 X509_POLICY_TREE *
 X509_STORE_CTX_get0_policy_tree(X509_STORE_CTX *ctx)
 {
 	return ctx->tree;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_policy_tree)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_policy_tree);
 
 int
 X509_STORE_CTX_get_explicit_policy(X509_STORE_CTX *ctx)
 {
 	return ctx->explicit_policy;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_explicit_policy)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_explicit_policy);
 
 int
 X509_STORE_CTX_get_num_untrusted(X509_STORE_CTX *ctx)
 {
 	return ctx->num_untrusted;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted)
+LCRYPTO_ALIAS(X509_STORE_CTX_get_num_untrusted);
 
 int
 X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
@@ -2660,14 +2660,14 @@ X509_STORE_CTX_set_default(X509_STORE_CTX *ctx, const char *name)
 		return 0;
 	return X509_VERIFY_PARAM_inherit(ctx->param, param);
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set_default)
+LCRYPTO_ALIAS(X509_STORE_CTX_set_default);
 
 X509_VERIFY_PARAM *
 X509_STORE_CTX_get0_param(X509_STORE_CTX *ctx)
 {
 	return ctx->param;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_get0_param)
+LCRYPTO_ALIAS(X509_STORE_CTX_get0_param);
 
 void
 X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
@@ -2676,7 +2676,7 @@ X509_STORE_CTX_set0_param(X509_STORE_CTX *ctx, X509_VERIFY_PARAM *param)
 		X509_VERIFY_PARAM_free(ctx->param);
 	ctx->param = param;
 }
-LCRYPTO_ALIAS(X509_STORE_CTX_set0_param)
+LCRYPTO_ALIAS(X509_STORE_CTX_set0_param);
 
 /*
  * Check if |bits| are adequate for |security level|.
diff --git a/lib/libcrypto/x509/x509_vpm.c b/lib/libcrypto/x509/x509_vpm.c
index 724a28fc1b7..cb13267b753 100644
--- a/lib/libcrypto/x509/x509_vpm.c
+++ b/lib/libcrypto/x509/x509_vpm.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509_vpm.c,v 1.32 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509_vpm.c,v 1.33 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2004.
  */
@@ -218,7 +218,7 @@ X509_VERIFY_PARAM_new(void)
 	x509_verify_param_zero(param);
 	return param;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_new)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_new);
 
 void
 X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
@@ -229,7 +229,7 @@ X509_VERIFY_PARAM_free(X509_VERIFY_PARAM *param)
 	free(param->id);
 	free(param);
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_free)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_free);
 
 /*
  * This function determines how parameters are "inherited" from one structure
@@ -358,7 +358,7 @@ X509_VERIFY_PARAM_inherit(X509_VERIFY_PARAM *dest, const X509_VERIFY_PARAM *src)
 
 	return 1;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_inherit);
 
 int
 X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from)
@@ -371,7 +371,7 @@ X509_VERIFY_PARAM_set1(X509_VERIFY_PARAM *to, const X509_VERIFY_PARAM *from)
 	to->inh_flags = save_flags;
 	return ret;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1);
 
 static int
 x509_param_set1_internal(char **pdest, size_t *pdestlen,  const char *src,
@@ -416,7 +416,7 @@ X509_VERIFY_PARAM_set1_name(X509_VERIFY_PARAM *param, const char *name)
 		return 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_name);
 
 int
 X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags)
@@ -426,7 +426,7 @@ X509_VERIFY_PARAM_set_flags(X509_VERIFY_PARAM *param, unsigned long flags)
 		param->flags |= X509_V_FLAG_POLICY_CHECK;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_flags);
 
 int
 X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags)
@@ -434,49 +434,49 @@ X509_VERIFY_PARAM_clear_flags(X509_VERIFY_PARAM *param, unsigned long flags)
 	param->flags &= ~flags;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_clear_flags);
 
 unsigned long
 X509_VERIFY_PARAM_get_flags(X509_VERIFY_PARAM *param)
 {
 	return param->flags;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_flags);
 
 int
 X509_VERIFY_PARAM_set_purpose(X509_VERIFY_PARAM *param, int purpose)
 {
 	return X509_PURPOSE_set(&param->purpose, purpose);
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_purpose);
 
 int
 X509_VERIFY_PARAM_set_trust(X509_VERIFY_PARAM *param, int trust)
 {
 	return X509_TRUST_set(&param->trust, trust);
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_trust);
 
 void
 X509_VERIFY_PARAM_set_depth(X509_VERIFY_PARAM *param, int depth)
 {
 	param->depth = depth;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_depth);
 
 void
 X509_VERIFY_PARAM_set_auth_level(X509_VERIFY_PARAM *param, int auth_level)
 {
 	param->security_level = auth_level;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_auth_level);
 
 time_t
 X509_VERIFY_PARAM_get_time(const X509_VERIFY_PARAM *param)
 {
 	return param->check_time;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_time);
 
 void
 X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t)
@@ -484,7 +484,7 @@ X509_VERIFY_PARAM_set_time(X509_VERIFY_PARAM *param, time_t t)
 	param->check_time = t;
 	param->flags |= X509_V_FLAG_USE_CHECK_TIME;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_time);
 
 int
 X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy)
@@ -498,7 +498,7 @@ X509_VERIFY_PARAM_add0_policy(X509_VERIFY_PARAM *param, ASN1_OBJECT *policy)
 		return 0;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_policy);
 
 int
 X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
@@ -534,7 +534,7 @@ X509_VERIFY_PARAM_set1_policies(X509_VERIFY_PARAM *param,
 	param->flags |= X509_V_FLAG_POLICY_CHECK;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_policies);
 
 int
 X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
@@ -545,7 +545,7 @@ X509_VERIFY_PARAM_set1_host(X509_VERIFY_PARAM *param,
 	param->id->poisoned = 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_host);
 
 int
 X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
@@ -556,21 +556,21 @@ X509_VERIFY_PARAM_add1_host(X509_VERIFY_PARAM *param,
 	param->id->poisoned = 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add1_host);
 
 void
 X509_VERIFY_PARAM_set_hostflags(X509_VERIFY_PARAM *param, unsigned int flags)
 {
 	param->id->hostflags = flags;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set_hostflags);
 
 char *
 X509_VERIFY_PARAM_get0_peername(X509_VERIFY_PARAM *param)
 {
 	return param->id->peername;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_peername);
 
 int
 X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,  const char *email,
@@ -582,7 +582,7 @@ X509_VERIFY_PARAM_set1_email(X509_VERIFY_PARAM *param,  const char *email,
 	param->id->poisoned = 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_email);
 
 int
 X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip,
@@ -597,7 +597,7 @@ X509_VERIFY_PARAM_set1_ip(X509_VERIFY_PARAM *param, const unsigned char *ip,
 	param->id->poisoned = 1;
 	return 0;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip);
 
 int
 X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc)
@@ -608,21 +608,21 @@ X509_VERIFY_PARAM_set1_ip_asc(X509_VERIFY_PARAM *param, const char *ipasc)
 	iplen = (size_t)a2i_ipadd(ipout, ipasc);
 	return X509_VERIFY_PARAM_set1_ip(param, ipout, iplen);
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_set1_ip_asc);
 
 int
 X509_VERIFY_PARAM_get_depth(const X509_VERIFY_PARAM *param)
 {
 	return param->depth;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_depth);
 
 const char *
 X509_VERIFY_PARAM_get0_name(const X509_VERIFY_PARAM *param)
 {
 	return param->name;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0_name);
 
 static const X509_VERIFY_PARAM_ID _empty_id = { NULL };
 
@@ -704,7 +704,7 @@ X509_VERIFY_PARAM_add0_table(X509_VERIFY_PARAM *param)
 		return 0;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_add0_table);
 
 int
 X509_VERIFY_PARAM_get_count(void)
@@ -714,7 +714,7 @@ X509_VERIFY_PARAM_get_count(void)
 		num += sk_X509_VERIFY_PARAM_num(param_table);
 	return num;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get_count);
 
 const X509_VERIFY_PARAM *
 X509_VERIFY_PARAM_get0(int id)
@@ -724,7 +724,7 @@ X509_VERIFY_PARAM_get0(int id)
 		return default_table + id;
 	return sk_X509_VERIFY_PARAM_value(param_table, id - num);
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_get0);
 
 const X509_VERIFY_PARAM *
 X509_VERIFY_PARAM_lookup(const char *name)
@@ -747,7 +747,7 @@ X509_VERIFY_PARAM_lookup(const char *name)
 	}
 	return NULL;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_lookup);
 
 void
 X509_VERIFY_PARAM_table_cleanup(void)
@@ -757,4 +757,4 @@ X509_VERIFY_PARAM_table_cleanup(void)
 		    X509_VERIFY_PARAM_free);
 	param_table = NULL;
 }
-LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup)
+LCRYPTO_ALIAS(X509_VERIFY_PARAM_table_cleanup);
diff --git a/lib/libcrypto/x509/x509cset.c b/lib/libcrypto/x509/x509cset.c
index a75a63b03b4..7904a7d6700 100644
--- a/lib/libcrypto/x509/x509cset.c
+++ b/lib/libcrypto/x509/x509cset.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509cset.c,v 1.18 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509cset.c,v 1.19 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 2001.
  */
@@ -71,7 +71,7 @@ X509_CRL_up_ref(X509_CRL *x)
 	int refs = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509_CRL);
 	return (refs > 1) ? 1 : 0;
 }
-LCRYPTO_ALIAS(X509_CRL_up_ref)
+LCRYPTO_ALIAS(X509_CRL_up_ref);
 
 int
 X509_CRL_set_version(X509_CRL *x, long version)
@@ -84,7 +84,7 @@ X509_CRL_set_version(X509_CRL *x, long version)
 	}
 	return (ASN1_INTEGER_set(x->crl->version, version));
 }
-LCRYPTO_ALIAS(X509_CRL_set_version)
+LCRYPTO_ALIAS(X509_CRL_set_version);
 
 int
 X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
@@ -93,7 +93,7 @@ X509_CRL_set_issuer_name(X509_CRL *x, X509_NAME *name)
 		return (0);
 	return (X509_NAME_set(&x->crl->issuer, name));
 }
-LCRYPTO_ALIAS(X509_CRL_set_issuer_name)
+LCRYPTO_ALIAS(X509_CRL_set_issuer_name);
 
 int
 X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
@@ -112,14 +112,14 @@ X509_CRL_set_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_CRL_set_lastUpdate)
+LCRYPTO_ALIAS(X509_CRL_set_lastUpdate);
 
 int
 X509_CRL_set1_lastUpdate(X509_CRL *x, const ASN1_TIME *tm)
 {
 	return X509_CRL_set_lastUpdate(x, tm);
 }
-LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate)
+LCRYPTO_ALIAS(X509_CRL_set1_lastUpdate);
 
 int
 X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
@@ -138,14 +138,14 @@ X509_CRL_set_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_CRL_set_nextUpdate)
+LCRYPTO_ALIAS(X509_CRL_set_nextUpdate);
 
 int
 X509_CRL_set1_nextUpdate(X509_CRL *x, const ASN1_TIME *tm)
 {
 	return X509_CRL_set_nextUpdate(x, tm);
 }
-LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate)
+LCRYPTO_ALIAS(X509_CRL_set1_nextUpdate);
 
 int
 X509_CRL_sort(X509_CRL *c)
@@ -163,28 +163,28 @@ X509_CRL_sort(X509_CRL *c)
 	c->crl->enc.modified = 1;
 	return 1;
 }
-LCRYPTO_ALIAS(X509_CRL_sort)
+LCRYPTO_ALIAS(X509_CRL_sort);
 
 const STACK_OF(X509_EXTENSION) *
 X509_REVOKED_get0_extensions(const X509_REVOKED *x)
 {
 	return x->extensions;
 }
-LCRYPTO_ALIAS(X509_REVOKED_get0_extensions)
+LCRYPTO_ALIAS(X509_REVOKED_get0_extensions);
 
 const ASN1_TIME *
 X509_REVOKED_get0_revocationDate(const X509_REVOKED *x)
 {
 	return x->revocationDate;
 }
-LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate)
+LCRYPTO_ALIAS(X509_REVOKED_get0_revocationDate);
 
 const ASN1_INTEGER *
 X509_REVOKED_get0_serialNumber(const X509_REVOKED *x)
 {
 	return x->serialNumber;
 }
-LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber)
+LCRYPTO_ALIAS(X509_REVOKED_get0_serialNumber);
 
 int
 X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm)
@@ -203,7 +203,7 @@ X509_REVOKED_set_revocationDate(X509_REVOKED *x, ASN1_TIME *tm)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate)
+LCRYPTO_ALIAS(X509_REVOKED_set_revocationDate);
 
 int
 X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial)
@@ -222,7 +222,7 @@ X509_REVOKED_set_serialNumber(X509_REVOKED *x, ASN1_INTEGER *serial)
 	}
 	return (in != NULL);
 }
-LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber)
+LCRYPTO_ALIAS(X509_REVOKED_set_serialNumber);
 
 int
 i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp)
@@ -230,4 +230,4 @@ i2d_re_X509_CRL_tbs(X509_CRL *crl, unsigned char **pp)
 	crl->crl->enc.modified = 1;
 	return i2d_X509_CRL_INFO(crl->crl, pp);
 }
-LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs)
+LCRYPTO_ALIAS(i2d_re_X509_CRL_tbs);
diff --git a/lib/libcrypto/x509/x509name.c b/lib/libcrypto/x509/x509name.c
index 19a253da4da..a6e4dbef89b 100644
--- a/lib/libcrypto/x509/x509name.c
+++ b/lib/libcrypto/x509/x509name.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509name.c,v 1.30 2022/12/26 07:18:53 jmc Exp $ */
+/* $OpenBSD: x509name.c,v 1.31 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -78,7 +78,7 @@ X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len)
 		return (-1);
 	return (X509_NAME_get_text_by_OBJ(name, obj, buf, len));
 }
-LCRYPTO_ALIAS(X509_NAME_get_text_by_NID)
+LCRYPTO_ALIAS(X509_NAME_get_text_by_NID);
 
 int
 X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf,
@@ -100,7 +100,7 @@ X509_NAME_get_text_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, char *buf,
 	}
 	return (i);
 }
-LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_get_text_by_OBJ);
 
 int
 X509_NAME_entry_count(const X509_NAME *name)
@@ -109,7 +109,7 @@ X509_NAME_entry_count(const X509_NAME *name)
 		return (0);
 	return (sk_X509_NAME_ENTRY_num(name->entries));
 }
-LCRYPTO_ALIAS(X509_NAME_entry_count)
+LCRYPTO_ALIAS(X509_NAME_entry_count);
 
 int
 X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos)
@@ -121,7 +121,7 @@ X509_NAME_get_index_by_NID(const X509_NAME *name, int nid, int lastpos)
 		return (-2);
 	return (X509_NAME_get_index_by_OBJ(name, obj, lastpos));
 }
-LCRYPTO_ALIAS(X509_NAME_get_index_by_NID)
+LCRYPTO_ALIAS(X509_NAME_get_index_by_NID);
 
 /* NOTE: you should be passing -1, not 0 as lastpos */
 int
@@ -145,7 +145,7 @@ X509_NAME_get_index_by_OBJ(const X509_NAME *name, const ASN1_OBJECT *obj,
 	}
 	return (-1);
 }
-LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_get_index_by_OBJ);
 
 X509_NAME_ENTRY *
 X509_NAME_get_entry(const X509_NAME *name, int loc)
@@ -156,7 +156,7 @@ X509_NAME_get_entry(const X509_NAME *name, int loc)
 	else
 		return (sk_X509_NAME_ENTRY_value(name->entries, loc));
 }
-LCRYPTO_ALIAS(X509_NAME_get_entry)
+LCRYPTO_ALIAS(X509_NAME_get_entry);
 
 X509_NAME_ENTRY *
 X509_NAME_delete_entry(X509_NAME *name, int loc)
@@ -195,7 +195,7 @@ X509_NAME_delete_entry(X509_NAME *name, int loc)
 			sk_X509_NAME_ENTRY_value(sk, i)->set--;
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_NAME_delete_entry)
+LCRYPTO_ALIAS(X509_NAME_delete_entry);
 
 int
 X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
@@ -211,7 +211,7 @@ X509_NAME_add_entry_by_OBJ(X509_NAME *name, const ASN1_OBJECT *obj, int type,
 	X509_NAME_ENTRY_free(ne);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_OBJ);
 
 int
 X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
@@ -227,7 +227,7 @@ X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
 	X509_NAME_ENTRY_free(ne);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID)
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_NID);
 
 int
 X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
@@ -243,7 +243,7 @@ X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
 	X509_NAME_ENTRY_free(ne);
 	return ret;
 }
-LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt)
+LCRYPTO_ALIAS(X509_NAME_add_entry_by_txt);
 
 /* if set is -1, append to previous set, 0 'a new one', and 1,
  * prepend to the guy we are about to stomp on. */
@@ -302,7 +302,7 @@ err:
 		X509_NAME_ENTRY_free(new_name);
 	return (0);
 }
-LCRYPTO_ALIAS(X509_NAME_add_entry)
+LCRYPTO_ALIAS(X509_NAME_add_entry);
 
 X509_NAME_ENTRY *
 X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
@@ -321,7 +321,7 @@ X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
 	ASN1_OBJECT_free(obj);
 	return nentry;
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_txt);
 
 X509_NAME_ENTRY *
 X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type,
@@ -339,7 +339,7 @@ X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid, int type,
 	ASN1_OBJECT_free(obj);
 	return nentry;
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_NID);
 
 X509_NAME_ENTRY *
 X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne, const ASN1_OBJECT *obj,
@@ -367,7 +367,7 @@ err:
 		X509_NAME_ENTRY_free(ret);
 	return (NULL);
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_create_by_OBJ);
 
 int
 X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj)
@@ -380,7 +380,7 @@ X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, const ASN1_OBJECT *obj)
 	ne->object = OBJ_dup(obj);
 	return ((ne->object == NULL) ? 0 : 1);
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_object);
 
 int
 X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
@@ -406,7 +406,7 @@ X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
 	}
 	return (1);
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set_data);
 
 ASN1_OBJECT *
 X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne)
@@ -415,7 +415,7 @@ X509_NAME_ENTRY_get_object(const X509_NAME_ENTRY *ne)
 		return (NULL);
 	return (ne->object);
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_get_object);
 
 ASN1_STRING *
 X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne)
@@ -424,11 +424,11 @@ X509_NAME_ENTRY_get_data(const X509_NAME_ENTRY *ne)
 		return (NULL);
 	return (ne->value);
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_get_data);
 
 int
 X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)
 {
 	return (ne->set);
 }
-LCRYPTO_ALIAS(X509_NAME_ENTRY_set)
+LCRYPTO_ALIAS(X509_NAME_ENTRY_set);
diff --git a/lib/libcrypto/x509/x509rset.c b/lib/libcrypto/x509/x509rset.c
index 640a850800b..f097a379fb8 100644
--- a/lib/libcrypto/x509/x509rset.c
+++ b/lib/libcrypto/x509/x509rset.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509rset.c,v 1.11 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509rset.c,v 1.12 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -73,14 +73,14 @@ X509_REQ_set_version(X509_REQ *x, long version)
 	x->req_info->enc.modified = 1;
 	return (ASN1_INTEGER_set(x->req_info->version, version));
 }
-LCRYPTO_ALIAS(X509_REQ_set_version)
+LCRYPTO_ALIAS(X509_REQ_set_version);
 
 long
 X509_REQ_get_version(const X509_REQ *x)
 {
 	return ASN1_INTEGER_get(x->req_info->version);
 }
-LCRYPTO_ALIAS(X509_REQ_get_version)
+LCRYPTO_ALIAS(X509_REQ_get_version);
 
 int
 X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name)
@@ -90,14 +90,14 @@ X509_REQ_set_subject_name(X509_REQ *x, X509_NAME *name)
 	x->req_info->enc.modified = 1;
 	return (X509_NAME_set(&x->req_info->subject, name));
 }
-LCRYPTO_ALIAS(X509_REQ_set_subject_name)
+LCRYPTO_ALIAS(X509_REQ_set_subject_name);
 
 X509_NAME *
 X509_REQ_get_subject_name(const X509_REQ *x)
 {
 	return x->req_info->subject;
 }
-LCRYPTO_ALIAS(X509_REQ_get_subject_name)
+LCRYPTO_ALIAS(X509_REQ_get_subject_name);
 
 int
 X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey)
@@ -107,4 +107,4 @@ X509_REQ_set_pubkey(X509_REQ *x, EVP_PKEY *pkey)
 	x->req_info->enc.modified = 1;
 	return (X509_PUBKEY_set(&x->req_info->pubkey, pkey));
 }
-LCRYPTO_ALIAS(X509_REQ_set_pubkey)
+LCRYPTO_ALIAS(X509_REQ_set_pubkey);
diff --git a/lib/libcrypto/x509/x509spki.c b/lib/libcrypto/x509/x509spki.c
index 2c1b506dcdc..04c9a6f01b0 100644
--- a/lib/libcrypto/x509/x509spki.c
+++ b/lib/libcrypto/x509/x509spki.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509spki.c,v 1.15 2022/11/14 17:48:50 beck Exp $ */
+/* $OpenBSD: x509spki.c,v 1.16 2023/02/16 08:38:17 tb Exp $ */
 /* Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL
  * project 1999.
  */
@@ -70,7 +70,7 @@ NETSCAPE_SPKI_set_pubkey(NETSCAPE_SPKI *x, EVP_PKEY *pkey)
 		return (0);
 	return (X509_PUBKEY_set(&(x->spkac->pubkey), pkey));
 }
-LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_set_pubkey);
 
 EVP_PKEY *
 NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x)
@@ -79,7 +79,7 @@ NETSCAPE_SPKI_get_pubkey(NETSCAPE_SPKI *x)
 		return (NULL);
 	return (X509_PUBKEY_get(x->spkac->pubkey));
 }
-LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_get_pubkey);
 
 /* Load a Netscape SPKI from a base64 encoded string */
 
@@ -108,7 +108,7 @@ NETSCAPE_SPKI_b64_decode(const char *str, int len)
 	free(spki_der);
 	return spki;
 }
-LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_decode);
 
 /* Generate a base64 encoded string from an SPKI */
 
@@ -133,4 +133,4 @@ NETSCAPE_SPKI_b64_encode(NETSCAPE_SPKI *spki)
 	free(der_spki);
 	return b64_str;
 }
-LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_b64_encode);
diff --git a/lib/libcrypto/x509/x509type.c b/lib/libcrypto/x509/x509type.c
index 7e10fb540d8..ebc02c59297 100644
--- a/lib/libcrypto/x509/x509type.c
+++ b/lib/libcrypto/x509/x509type.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x509type.c,v 1.17 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x509type.c,v 1.18 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -124,4 +124,4 @@ X509_certificate_type(const X509 *x, const EVP_PKEY *pkey)
 		ret |= EVP_PKT_EXP;
 	return (ret);
 }
-LCRYPTO_ALIAS(X509_certificate_type)
+LCRYPTO_ALIAS(X509_certificate_type);
diff --git a/lib/libcrypto/x509/x_all.c b/lib/libcrypto/x509/x_all.c
index 819162dc31d..cd6da9f409e 100644
--- a/lib/libcrypto/x509/x_all.c
+++ b/lib/libcrypto/x509/x_all.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: x_all.c,v 1.29 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: x_all.c,v 1.30 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -80,84 +80,84 @@ d2i_X509_bio(BIO *bp, X509 **x509)
 {
 	return ASN1_item_d2i_bio(&X509_it, bp, x509);
 }
-LCRYPTO_ALIAS(d2i_X509_bio)
+LCRYPTO_ALIAS(d2i_X509_bio);
 
 int
 i2d_X509_bio(BIO *bp, X509 *x509)
 {
 	return ASN1_item_i2d_bio(&X509_it, bp, x509);
 }
-LCRYPTO_ALIAS(i2d_X509_bio)
+LCRYPTO_ALIAS(i2d_X509_bio);
 
 X509 *
 d2i_X509_fp(FILE *fp, X509 **x509)
 {
 	return ASN1_item_d2i_fp(&X509_it, fp, x509);
 }
-LCRYPTO_ALIAS(d2i_X509_fp)
+LCRYPTO_ALIAS(d2i_X509_fp);
 
 int
 i2d_X509_fp(FILE *fp, X509 *x509)
 {
 	return ASN1_item_i2d_fp(&X509_it, fp, x509);
 }
-LCRYPTO_ALIAS(i2d_X509_fp)
+LCRYPTO_ALIAS(i2d_X509_fp);
 
 X509_CRL *
 d2i_X509_CRL_bio(BIO *bp, X509_CRL **crl)
 {
 	return ASN1_item_d2i_bio(&X509_CRL_it, bp, crl);
 }
-LCRYPTO_ALIAS(d2i_X509_CRL_bio)
+LCRYPTO_ALIAS(d2i_X509_CRL_bio);
 
 int
 i2d_X509_CRL_bio(BIO *bp, X509_CRL *crl)
 {
 	return ASN1_item_i2d_bio(&X509_CRL_it, bp, crl);
 }
-LCRYPTO_ALIAS(i2d_X509_CRL_bio)
+LCRYPTO_ALIAS(i2d_X509_CRL_bio);
 
 X509_CRL *
 d2i_X509_CRL_fp(FILE *fp, X509_CRL **crl)
 {
 	return ASN1_item_d2i_fp(&X509_CRL_it, fp, crl);
 }
-LCRYPTO_ALIAS(d2i_X509_CRL_fp)
+LCRYPTO_ALIAS(d2i_X509_CRL_fp);
 
 int
 i2d_X509_CRL_fp(FILE *fp, X509_CRL *crl)
 {
 	return ASN1_item_i2d_fp(&X509_CRL_it, fp, crl);
 }
-LCRYPTO_ALIAS(i2d_X509_CRL_fp)
+LCRYPTO_ALIAS(i2d_X509_CRL_fp);
 
 X509_REQ *
 d2i_X509_REQ_bio(BIO *bp, X509_REQ **req)
 {
 	return ASN1_item_d2i_bio(&X509_REQ_it, bp, req);
 }
-LCRYPTO_ALIAS(d2i_X509_REQ_bio)
+LCRYPTO_ALIAS(d2i_X509_REQ_bio);
 
 int
 i2d_X509_REQ_bio(BIO *bp, X509_REQ *req)
 {
 	return ASN1_item_i2d_bio(&X509_REQ_it, bp, req);
 }
-LCRYPTO_ALIAS(i2d_X509_REQ_bio)
+LCRYPTO_ALIAS(i2d_X509_REQ_bio);
 
 X509_REQ *
 d2i_X509_REQ_fp(FILE *fp, X509_REQ **req)
 {
 	return ASN1_item_d2i_fp(&X509_REQ_it, fp, req);
 }
-LCRYPTO_ALIAS(d2i_X509_REQ_fp)
+LCRYPTO_ALIAS(d2i_X509_REQ_fp);
 
 int
 i2d_X509_REQ_fp(FILE *fp, X509_REQ *req)
 {
 	return ASN1_item_i2d_fp(&X509_REQ_it, fp, req);
 }
-LCRYPTO_ALIAS(i2d_X509_REQ_fp)
+LCRYPTO_ALIAS(i2d_X509_REQ_fp);
 
 #ifndef OPENSSL_NO_RSA
 RSA *
@@ -165,56 +165,56 @@ d2i_RSAPrivateKey_bio(BIO *bp, RSA **rsa)
 {
 	return ASN1_item_d2i_bio(&RSAPrivateKey_it, bp, rsa);
 }
-LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio)
+LCRYPTO_ALIAS(d2i_RSAPrivateKey_bio);
 
 int
 i2d_RSAPrivateKey_bio(BIO *bp, RSA *rsa)
 {
 	return ASN1_item_i2d_bio(&RSAPrivateKey_it, bp, rsa);
 }
-LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio)
+LCRYPTO_ALIAS(i2d_RSAPrivateKey_bio);
 
 RSA *
 d2i_RSAPrivateKey_fp(FILE *fp, RSA **rsa)
 {
 	return ASN1_item_d2i_fp(&RSAPrivateKey_it, fp, rsa);
 }
-LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp)
+LCRYPTO_ALIAS(d2i_RSAPrivateKey_fp);
 
 int
 i2d_RSAPrivateKey_fp(FILE *fp, RSA *rsa)
 {
 	return ASN1_item_i2d_fp(&RSAPrivateKey_it, fp, rsa);
 }
-LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp)
+LCRYPTO_ALIAS(i2d_RSAPrivateKey_fp);
 
 RSA *
 d2i_RSAPublicKey_bio(BIO *bp, RSA **rsa)
 {
 	return ASN1_item_d2i_bio(&RSAPublicKey_it, bp, rsa);
 }
-LCRYPTO_ALIAS(d2i_RSAPublicKey_bio)
+LCRYPTO_ALIAS(d2i_RSAPublicKey_bio);
 
 int
 i2d_RSAPublicKey_bio(BIO *bp, RSA *rsa)
 {
 	return ASN1_item_i2d_bio(&RSAPublicKey_it, bp, rsa);
 }
-LCRYPTO_ALIAS(i2d_RSAPublicKey_bio)
+LCRYPTO_ALIAS(i2d_RSAPublicKey_bio);
 
 RSA *
 d2i_RSAPublicKey_fp(FILE *fp, RSA **rsa)
 {
 	return ASN1_item_d2i_fp(&RSAPublicKey_it, fp, rsa);
 }
-LCRYPTO_ALIAS(d2i_RSAPublicKey_fp)
+LCRYPTO_ALIAS(d2i_RSAPublicKey_fp);
 
 int
 i2d_RSAPublicKey_fp(FILE *fp, RSA *rsa)
 {
 	return ASN1_item_i2d_fp(&RSAPublicKey_it, fp, rsa);
 }
-LCRYPTO_ALIAS(i2d_RSAPublicKey_fp)
+LCRYPTO_ALIAS(i2d_RSAPublicKey_fp);
 #endif
 
 #ifndef OPENSSL_NO_DSA
@@ -223,28 +223,28 @@ d2i_DSAPrivateKey_bio(BIO *bp, DSA **dsa)
 {
 	return ASN1_item_d2i_bio(&DSAPrivateKey_it, bp, dsa);
 }
-LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio)
+LCRYPTO_ALIAS(d2i_DSAPrivateKey_bio);
 
 int
 i2d_DSAPrivateKey_bio(BIO *bp, DSA *dsa)
 {
 	return ASN1_item_i2d_bio(&DSAPrivateKey_it, bp, dsa);
 }
-LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio)
+LCRYPTO_ALIAS(i2d_DSAPrivateKey_bio);
 
 DSA *
 d2i_DSAPrivateKey_fp(FILE *fp, DSA **dsa)
 {
 	return ASN1_item_d2i_fp(&DSAPrivateKey_it, fp, dsa);
 }
-LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp)
+LCRYPTO_ALIAS(d2i_DSAPrivateKey_fp);
 
 int
 i2d_DSAPrivateKey_fp(FILE *fp, DSA *dsa)
 {
 	return ASN1_item_i2d_fp(&DSAPrivateKey_it, fp, dsa);
 }
-LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp)
+LCRYPTO_ALIAS(i2d_DSAPrivateKey_fp);
 #endif
 
 #ifndef OPENSSL_NO_EC
@@ -253,28 +253,28 @@ d2i_ECPrivateKey_bio(BIO *bp, EC_KEY **eckey)
 {
 	return ASN1_d2i_bio_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, bp, eckey);
 }
-LCRYPTO_ALIAS(d2i_ECPrivateKey_bio)
+LCRYPTO_ALIAS(d2i_ECPrivateKey_bio);
 
 int
 i2d_ECPrivateKey_bio(BIO *bp, EC_KEY *eckey)
 {
 	return ASN1_i2d_bio_of(EC_KEY, i2d_ECPrivateKey, bp, eckey);
 }
-LCRYPTO_ALIAS(i2d_ECPrivateKey_bio)
+LCRYPTO_ALIAS(i2d_ECPrivateKey_bio);
 
 EC_KEY *
 d2i_ECPrivateKey_fp(FILE *fp, EC_KEY **eckey)
 {
 	return ASN1_d2i_fp_of(EC_KEY, EC_KEY_new, d2i_ECPrivateKey, fp, eckey);
 }
-LCRYPTO_ALIAS(d2i_ECPrivateKey_fp)
+LCRYPTO_ALIAS(d2i_ECPrivateKey_fp);
 
 int
 i2d_ECPrivateKey_fp(FILE *fp, EC_KEY *eckey)
 {
 	return ASN1_i2d_fp_of(EC_KEY, i2d_ECPrivateKey, fp, eckey);
 }
-LCRYPTO_ALIAS(i2d_ECPrivateKey_fp)
+LCRYPTO_ALIAS(i2d_ECPrivateKey_fp);
 #endif
 
 X509_SIG *
@@ -282,28 +282,28 @@ d2i_PKCS8_bio(BIO *bp, X509_SIG **p8)
 {
 	return ASN1_item_d2i_bio(&X509_SIG_it, bp, p8);
 }
-LCRYPTO_ALIAS(d2i_PKCS8_bio)
+LCRYPTO_ALIAS(d2i_PKCS8_bio);
 
 int
 i2d_PKCS8_bio(BIO *bp, X509_SIG *p8)
 {
 	return ASN1_item_i2d_bio(&X509_SIG_it, bp, p8);
 }
-LCRYPTO_ALIAS(i2d_PKCS8_bio)
+LCRYPTO_ALIAS(i2d_PKCS8_bio);
 
 X509_SIG *
 d2i_PKCS8_fp(FILE *fp, X509_SIG **p8)
 {
 	return ASN1_item_d2i_fp(&X509_SIG_it, fp, p8);
 }
-LCRYPTO_ALIAS(d2i_PKCS8_fp)
+LCRYPTO_ALIAS(d2i_PKCS8_fp);
 
 int
 i2d_PKCS8_fp(FILE *fp, X509_SIG *p8)
 {
 	return ASN1_item_i2d_fp(&X509_SIG_it, fp, p8);
 }
-LCRYPTO_ALIAS(i2d_PKCS8_fp)
+LCRYPTO_ALIAS(i2d_PKCS8_fp);
 
 PKCS8_PRIV_KEY_INFO *
 d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf)
@@ -311,7 +311,7 @@ d2i_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO **p8inf)
 	return ASN1_item_d2i_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
 	    p8inf);
 }
-LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio)
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_bio);
 
 int
 i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
@@ -319,7 +319,7 @@ i2d_PKCS8_PRIV_KEY_INFO_bio(BIO *bp, PKCS8_PRIV_KEY_INFO *p8inf)
 	return ASN1_item_i2d_bio(&PKCS8_PRIV_KEY_INFO_it, bp,
 	    p8inf);
 }
-LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio)
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_bio);
 
 PKCS8_PRIV_KEY_INFO *
 d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf)
@@ -327,7 +327,7 @@ d2i_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO **p8inf)
 	return ASN1_item_d2i_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
 	    p8inf);
 }
-LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp)
+LCRYPTO_ALIAS(d2i_PKCS8_PRIV_KEY_INFO_fp);
 
 int
 i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
@@ -335,7 +335,7 @@ i2d_PKCS8_PRIV_KEY_INFO_fp(FILE *fp, PKCS8_PRIV_KEY_INFO *p8inf)
 	return ASN1_item_i2d_fp(&PKCS8_PRIV_KEY_INFO_it, fp,
 	    p8inf);
 }
-LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp)
+LCRYPTO_ALIAS(i2d_PKCS8_PRIV_KEY_INFO_fp);
 
 EVP_PKEY *
 d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
@@ -343,14 +343,14 @@ d2i_PrivateKey_bio(BIO *bp, EVP_PKEY **a)
 	return ASN1_d2i_bio_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
 	    bp, a);
 }
-LCRYPTO_ALIAS(d2i_PrivateKey_bio)
+LCRYPTO_ALIAS(d2i_PrivateKey_bio);
 
 int
 i2d_PrivateKey_bio(BIO *bp, EVP_PKEY *pkey)
 {
 	return ASN1_i2d_bio_of(EVP_PKEY, i2d_PrivateKey, bp, pkey);
 }
-LCRYPTO_ALIAS(i2d_PrivateKey_bio)
+LCRYPTO_ALIAS(i2d_PrivateKey_bio);
 
 EVP_PKEY *
 d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
@@ -358,14 +358,14 @@ d2i_PrivateKey_fp(FILE *fp, EVP_PKEY **a)
 	return ASN1_d2i_fp_of(EVP_PKEY, EVP_PKEY_new, d2i_AutoPrivateKey,
 	    fp, a);
 }
-LCRYPTO_ALIAS(d2i_PrivateKey_fp)
+LCRYPTO_ALIAS(d2i_PrivateKey_fp);
 
 int
 i2d_PrivateKey_fp(FILE *fp, EVP_PKEY *pkey)
 {
 	return ASN1_i2d_fp_of(EVP_PKEY, i2d_PrivateKey, fp, pkey);
 }
-LCRYPTO_ALIAS(i2d_PrivateKey_fp)
+LCRYPTO_ALIAS(i2d_PrivateKey_fp);
 
 int
 i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
@@ -380,7 +380,7 @@ i2d_PKCS8PrivateKeyInfo_bio(BIO *bp, EVP_PKEY *key)
 	PKCS8_PRIV_KEY_INFO_free(p8inf);
 	return ret;
 }
-LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio)
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_bio);
 
 int
 i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
@@ -394,7 +394,7 @@ i2d_PKCS8PrivateKeyInfo_fp(FILE *fp, EVP_PKEY *key)
 	PKCS8_PRIV_KEY_INFO_free(p8inf);
 	return ret;
 }
-LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp)
+LCRYPTO_ALIAS(i2d_PKCS8PrivateKeyInfo_fp);
 
 int
 X509_verify(X509 *a, EVP_PKEY *r)
@@ -404,7 +404,7 @@ X509_verify(X509 *a, EVP_PKEY *r)
 	return (ASN1_item_verify(&X509_CINF_it, a->sig_alg,
 	    a->signature, a->cert_info, r));
 }
-LCRYPTO_ALIAS(X509_verify)
+LCRYPTO_ALIAS(X509_verify);
 
 int
 X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
@@ -412,7 +412,7 @@ X509_REQ_verify(X509_REQ *a, EVP_PKEY *r)
 	return (ASN1_item_verify(&X509_REQ_INFO_it,
 	    a->sig_alg, a->signature, a->req_info, r));
 }
-LCRYPTO_ALIAS(X509_REQ_verify)
+LCRYPTO_ALIAS(X509_REQ_verify);
 
 int
 NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
@@ -420,7 +420,7 @@ NETSCAPE_SPKI_verify(NETSCAPE_SPKI *a, EVP_PKEY *r)
 	return (ASN1_item_verify(&NETSCAPE_SPKAC_it,
 	    a->sig_algor, a->signature, a->spkac, r));
 }
-LCRYPTO_ALIAS(NETSCAPE_SPKI_verify)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_verify);
 
 int
 X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -430,7 +430,7 @@ X509_sign(X509 *x, EVP_PKEY *pkey, const EVP_MD *md)
 	    x->cert_info->signature, x->sig_alg, x->signature,
 	    x->cert_info, pkey, md));
 }
-LCRYPTO_ALIAS(X509_sign)
+LCRYPTO_ALIAS(X509_sign);
 
 int
 X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
@@ -440,7 +440,7 @@ X509_sign_ctx(X509 *x, EVP_MD_CTX *ctx)
 	    x->cert_info->signature, x->sig_alg, x->signature,
 	    x->cert_info, ctx);
 }
-LCRYPTO_ALIAS(X509_sign_ctx)
+LCRYPTO_ALIAS(X509_sign_ctx);
 
 int
 X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -448,7 +448,7 @@ X509_REQ_sign(X509_REQ *x, EVP_PKEY *pkey, const EVP_MD *md)
 	return (ASN1_item_sign(&X509_REQ_INFO_it,
 	    x->sig_alg, NULL, x->signature, x->req_info, pkey, md));
 }
-LCRYPTO_ALIAS(X509_REQ_sign)
+LCRYPTO_ALIAS(X509_REQ_sign);
 
 int
 X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
@@ -456,7 +456,7 @@ X509_REQ_sign_ctx(X509_REQ *x, EVP_MD_CTX *ctx)
 	return ASN1_item_sign_ctx(&X509_REQ_INFO_it,
 	    x->sig_alg, NULL, x->signature, x->req_info, ctx);
 }
-LCRYPTO_ALIAS(X509_REQ_sign_ctx)
+LCRYPTO_ALIAS(X509_REQ_sign_ctx);
 
 int
 X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -465,7 +465,7 @@ X509_CRL_sign(X509_CRL *x, EVP_PKEY *pkey, const EVP_MD *md)
 	return(ASN1_item_sign(&X509_CRL_INFO_it, x->crl->sig_alg,
 	    x->sig_alg, x->signature, x->crl, pkey, md));
 }
-LCRYPTO_ALIAS(X509_CRL_sign)
+LCRYPTO_ALIAS(X509_CRL_sign);
 
 int
 X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
@@ -474,7 +474,7 @@ X509_CRL_sign_ctx(X509_CRL *x, EVP_MD_CTX *ctx)
 	return ASN1_item_sign_ctx(&X509_CRL_INFO_it,
 	    x->crl->sig_alg, x->sig_alg, x->signature, x->crl, ctx);
 }
-LCRYPTO_ALIAS(X509_CRL_sign_ctx)
+LCRYPTO_ALIAS(X509_CRL_sign_ctx);
 
 int
 NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
@@ -482,7 +482,7 @@ NETSCAPE_SPKI_sign(NETSCAPE_SPKI *x, EVP_PKEY *pkey, const EVP_MD *md)
 	return (ASN1_item_sign(&NETSCAPE_SPKAC_it,
 	    x->sig_algor, NULL, x->signature, x->spkac, pkey, md));
 }
-LCRYPTO_ALIAS(NETSCAPE_SPKI_sign)
+LCRYPTO_ALIAS(NETSCAPE_SPKI_sign);
 
 int
 X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
@@ -494,7 +494,7 @@ X509_pubkey_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
 		return 0;
 	return EVP_Digest(key->data, key->length, md, len, type, NULL);
 }
-LCRYPTO_ALIAS(X509_pubkey_digest)
+LCRYPTO_ALIAS(X509_pubkey_digest);
 
 int
 X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
@@ -503,7 +503,7 @@ X509_digest(const X509 *data, const EVP_MD *type, unsigned char *md,
 	return (ASN1_item_digest(&X509_it, type, (char *)data,
 	    md, len));
 }
-LCRYPTO_ALIAS(X509_digest)
+LCRYPTO_ALIAS(X509_digest);
 
 int
 X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
@@ -512,7 +512,7 @@ X509_CRL_digest(const X509_CRL *data, const EVP_MD *type, unsigned char *md,
 	return (ASN1_item_digest(&X509_CRL_it, type, (char *)data,
 	    md, len));
 }
-LCRYPTO_ALIAS(X509_CRL_digest)
+LCRYPTO_ALIAS(X509_CRL_digest);
 
 int
 X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
@@ -521,7 +521,7 @@ X509_REQ_digest(const X509_REQ *data, const EVP_MD *type, unsigned char *md,
 	return (ASN1_item_digest(&X509_REQ_it, type, (char *)data,
 	    md, len));
 }
-LCRYPTO_ALIAS(X509_REQ_digest)
+LCRYPTO_ALIAS(X509_REQ_digest);
 
 int
 X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
@@ -530,7 +530,7 @@ X509_NAME_digest(const X509_NAME *data, const EVP_MD *type, unsigned char *md,
 	return (ASN1_item_digest(&X509_NAME_it, type, (char *)data,
 	    md, len));
 }
-LCRYPTO_ALIAS(X509_NAME_digest)
+LCRYPTO_ALIAS(X509_NAME_digest);
 
 int
 X509_up_ref(X509 *x)
@@ -538,4 +538,4 @@ X509_up_ref(X509 *x)
 	int i = CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
 	return i > 1 ? 1 : 0;
 }
-LCRYPTO_ALIAS(X509_up_ref)
+LCRYPTO_ALIAS(X509_up_ref);
diff --git a/lib/libssl/bio_ssl.c b/lib/libssl/bio_ssl.c
index 98a730d1106..1a8cda84d65 100644
--- a/lib/libssl/bio_ssl.c
+++ b/lib/libssl/bio_ssl.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: bio_ssl.c,v 1.37 2022/11/26 16:08:55 tb Exp $ */
+/* $OpenBSD: bio_ssl.c,v 1.38 2023/02/16 08:38:17 tb Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
@@ -103,7 +103,7 @@ BIO_f_ssl(void)
 {
 	return (&methods_sslp);
 }
-LSSL_ALIAS(BIO_f_ssl)
+LSSL_ALIAS(BIO_f_ssl);
 
 static int
 ssl_new(BIO *bi)
@@ -533,7 +533,7 @@ BIO_new_ssl_connect(SSL_CTX *ctx)
 	BIO_free(ssl);
 	return (NULL);
 }
-LSSL_ALIAS(BIO_new_ssl_connect)
+LSSL_ALIAS(BIO_new_ssl_connect);
 
 BIO *
 BIO_new_ssl(SSL_CTX *ctx, int client)
@@ -558,7 +558,7 @@ BIO_new_ssl(SSL_CTX *ctx, int client)
 	BIO_free(ret);
 	return (NULL);
 }
-LSSL_ALIAS(BIO_new_ssl)
+LSSL_ALIAS(BIO_new_ssl);
 
 int
 BIO_ssl_copy_session_id(BIO *t, BIO *f)
diff --git a/lib/libssl/hidden/ssl_namespace.h b/lib/libssl/hidden/ssl_namespace.h
index 803f3e66bed..7a941a0e109 100644
--- a/lib/libssl/hidden/ssl_namespace.h
+++ b/lib/libssl/hidden/ssl_namespace.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: ssl_namespace.h,v 1.1 2022/11/11 11:25:18 beck Exp $	*/
+/*	$OpenBSD: ssl_namespace.h,v 1.2 2023/02/16 08:38:17 tb Exp $	*/
 /*
  * Copyright (c) 2016 Philip Guenther <guenther@openbsd.org>
  *
@@ -27,11 +27,11 @@
 #define LSSL_UNUSED(x)		typeof(x) x __attribute__((deprecated))
 #define LSSL_USED(x)		__attribute__((visibility("hidden")))	\
 				typeof(x) x asm("_lssl_"#x)
-#define LSSL_ALIAS(x)		asm(".global "#x"; "#x" = _lssl_"#x);
+#define LSSL_ALIAS(x)		asm(".global "#x"; "#x" = _lssl_"#x)
 #else
 #define LSSL_UNUSED(x)
 #define LSSL_USED(x)
-#define LSSL_ALIAS(x)
+#define LSSL_ALIAS(x)		asm("")
 #endif
 
 #endif	/* _LIBSSL_SSL_NAMESPACE_H_ */