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

8 files changed, 109 insertions, 109 deletions

diff --git a/src/lib/libcrypto/pkcs7/bio_pk7.c b/src/lib/libcrypto/pkcs7/bio_pk7.c
index 5f02535484..83cf70fd87 100644
--- a/src/lib/libcrypto/pkcs7/bio_pk7.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pk7_asn1.c b/src/lib/libcrypto/pkcs7/pk7_asn1.c
index b0c4ee8016..e5366ca45e 100644
--- a/src/lib/libcrypto/pkcs7/pk7_asn1.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pk7_attr.c b/src/lib/libcrypto/pkcs7/pk7_attr.c
index 1a5dc06dc5..5eff5241ef 100644
--- a/src/lib/libcrypto/pkcs7/pk7_attr.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pk7_doit.c b/src/lib/libcrypto/pkcs7/pk7_doit.c
index 3e2d4c2119..1fcc37a983 100644
--- a/src/lib/libcrypto/pkcs7/pk7_doit.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pk7_lib.c b/src/lib/libcrypto/pkcs7/pk7_lib.c
index efb6343f54..6eda698c94 100644
--- a/src/lib/libcrypto/pkcs7/pk7_lib.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pk7_mime.c b/src/lib/libcrypto/pkcs7/pk7_mime.c
index bf7d94584b..d5bc031e69 100644
--- a/src/lib/libcrypto/pkcs7/pk7_mime.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pk7_smime.c b/src/lib/libcrypto/pkcs7/pk7_smime.c
index 4324cf384b..c113ac3954 100644
--- a/src/lib/libcrypto/pkcs7/pk7_smime.c
+++ b/src/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/src/lib/libcrypto/pkcs7/pkcs7err.c b/src/lib/libcrypto/pkcs7/pkcs7err.c
index d2eab2d7f6..d3ca0ec6df 100644
--- a/src/lib/libcrypto/pkcs7/pkcs7err.c
+++ b/src/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);