Hi Mark,
On Thu, Mar 5, 2026 at 10:57 AM Mark Wielaard <[email protected]> wrote:
>
> This moves the assert from being checked at runtime to being checked
> at compile time.
>
> * libdwfl/dwfl_segment_report_module.c (dwfl_segment_report_module):
> Replace asserts with eu_static_assert.
> * libdwfl/linux-core-attach.c (core_set_initial_registers):
> Likewise.
> * libdwfl/linux-kernel-modules.c (check_notes): Likewise.
> * libebl/eblopenbackend.c (openbackend): Likewise.
> * libelf/elf_begin.c (file_read_elf): Likewise.
> (write_file): Likewise.
> * libelf/elf_clone.c (elf_clone): Likewise.
> * libelf/elf_getshdrstrndx.c (elf_getshdrstrndx): Likewise.
> * libelf/elf_newscn.c (elf_newscn): Likewise.
> * libelf/gelf_getauxv.c (gelf_getauxv): Likewise.
> * libelf/gelf_getdyn.c (gelf_getdyn): Likewise.
> * libelf/gelf_getlib.c (gelf_getlib): Likewise.
> * libelf/gelf_getsym.c (gelf_getsym): Likewise.
> * libelf/gelf_getsyminfo.c (gelf_getsyminfo): Likewise.
> * libelf/gelf_getsymshndx.c (gelf_getsymshndx): Likewise.
> * libelf/gelf_getverdaux.c (gelf_getverdaux): Likewise.
> * libelf/gelf_getverdef.c (gelf_getverdef): Likewise.
> * libelf/gelf_getvernaux.c (gelf_getvernaux): Likewise.
> * libelf/gelf_getverneed.c (gelf_getverneed): Likewise.
> * libelf/gelf_getversym.c (gelf_getversym): Likewise.
> * libelf/gelf_update_syminfo.c (gelf_update_syminfo): Likewise.
> * libelf/gelf_update_verdaux.c (gelf_update_verdaux): Likewise.
> * libelf/gelf_update_verdef.c (gelf_update_verdef): Likewise.
> * libelf/gelf_update_vernaux.c (gelf_update_vernaux): Likewise.
> * libelf/gelf_update_verneed.c (gelf_update_verneed): Likewise.
> * libelf/gelf_update_versym.c (gelf_update_versym): Likewise.
> * libelf/note_xlate.h (elf_cvt_note): Likewise.
> * libelf/version_xlate.h (elf_cvt_Verdef): Likewise.
> (elf_cvt_Verneed): Likewise.
> * src/arlib.c (arlib_init): Likewise.
> (arlib_add_symref): Likewise.
> * src/strip.c (handle_elf): Likewise.
> * src/unstrip.c (adjust_relocs): Likewise.
>
> Signed-off-by: Mark Wielaard <[email protected]>
Looks good, this compiles for me.
Aaron
> ---
> libdwfl/dwfl_segment_report_module.c | 2 +-
> libdwfl/linux-core-attach.c | 2 +-
> libdwfl/linux-kernel-modules.c | 4 ++--
> libebl/eblopenbackend.c | 12 ++++++------
> libelf/elf_begin.c | 8 ++++----
> libelf/elf_clone.c | 5 ++---
> libelf/elf_getshdrstrndx.c | 17 ++++++++---------
> libelf/elf_newscn.c | 12 ++++++------
> libelf/gelf_getauxv.c | 3 +--
> libelf/gelf_getdyn.c | 3 +--
> libelf/gelf_getlib.c | 5 ++---
> libelf/gelf_getsym.c | 3 +--
> libelf/gelf_getsyminfo.c | 5 ++---
> libelf/gelf_getsymshndx.c | 3 +--
> libelf/gelf_getverdaux.c | 5 ++---
> libelf/gelf_getverdef.c | 5 ++---
> libelf/gelf_getvernaux.c | 9 ++++-----
> libelf/gelf_getverneed.c | 9 ++++-----
> libelf/gelf_getversym.c | 5 ++---
> libelf/gelf_update_syminfo.c | 5 ++---
> libelf/gelf_update_verdaux.c | 5 ++---
> libelf/gelf_update_verdef.c | 5 ++---
> libelf/gelf_update_vernaux.c | 5 ++---
> libelf/gelf_update_verneed.c | 5 ++---
> libelf/gelf_update_versym.c | 5 ++---
> libelf/gnuhash_xlate.h | 1 -
> libelf/note_xlate.h | 2 +-
> libelf/version_xlate.h | 17 ++++++++---------
> src/arlib.c | 6 +++---
> src/strip.c | 20 ++++++++++++--------
> src/unstrip.c | 4 ++--
> 31 files changed, 90 insertions(+), 107 deletions(-)
>
> diff --git a/libdwfl/dwfl_segment_report_module.c
> b/libdwfl/dwfl_segment_report_module.c
> index f2f866c2c70f..8a485c062672 100644
> --- a/libdwfl/dwfl_segment_report_module.c
> +++ b/libdwfl/dwfl_segment_report_module.c
> @@ -537,7 +537,7 @@ dwfl_segment_report_module (Dwfl *dwfl, int ndx, const
> char *name,
> if (filesz > SIZE_MAX / sizeof (Elf32_Nhdr))
> continue;
>
> - assert (sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr));
> + eu_static_assert (sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr));
>
> void *notes;
> if (ei_data == MY_ELFDATA
> diff --git a/libdwfl/linux-core-attach.c b/libdwfl/linux-core-attach.c
> index 75e3c2198873..509e92b7c5e0 100644
> --- a/libdwfl/linux-core-attach.c
> +++ b/libdwfl/linux-core-attach.c
> @@ -275,7 +275,7 @@ core_set_initial_registers (Dwfl_Thread *thread, void
> *thread_arg_voidp)
> reg_desc += sizeof val64;
> val64 = (elf_getident (core, NULL)[EI_DATA] == ELFDATA2MSB
> ? be64toh (val64) : le64toh (val64));
> - assert (sizeof (*thread->unwound->regs) == sizeof val64);
> + eu_static_assert (sizeof (*thread->unwound->regs) == sizeof
> val64);
> val = val64;
> break;
> default:
> diff --git a/libdwfl/linux-kernel-modules.c b/libdwfl/linux-kernel-modules.c
> index e9faba26a720..dac64b3405c4 100644
> --- a/libdwfl/linux-kernel-modules.c
> +++ b/libdwfl/linux-kernel-modules.c
> @@ -577,8 +577,8 @@ check_notes (Dwfl_Module *mod, const char *notesfile,
> if (fd < 0)
> return 1;
>
> - assert (sizeof (Elf32_Nhdr) == sizeof (GElf_Nhdr));
> - assert (sizeof (Elf64_Nhdr) == sizeof (GElf_Nhdr));
> + eu_static_assert (sizeof (Elf32_Nhdr) == sizeof (GElf_Nhdr));
> + eu_static_assert (sizeof (Elf64_Nhdr) == sizeof (GElf_Nhdr));
> union
> {
> GElf_Nhdr nhdr;
> diff --git a/libebl/eblopenbackend.c b/libebl/eblopenbackend.c
> index b68dea7a0809..dbe4b94741d5 100644
> --- a/libebl/eblopenbackend.c
> +++ b/libebl/eblopenbackend.c
> @@ -311,12 +311,12 @@ openbackend (Elf *elf, const char *emulation, GElf_Half
> machine)
>
> /* We access some data structures directly. Make sure the 32 and
> 64 bit variants are laid out the same. */
> - assert (offsetof (Elf32_Ehdr, e_machine)
> - == offsetof (Elf64_Ehdr, e_machine));
> - assert (sizeof (((Elf32_Ehdr *) 0)->e_machine)
> - == sizeof (((Elf64_Ehdr *) 0)->e_machine));
> - assert (offsetof (Elf, state.elf32.ehdr)
> - == offsetof (Elf, state.elf64.ehdr));
> + eu_static_assert (offsetof (Elf32_Ehdr, e_machine)
> + == offsetof (Elf64_Ehdr, e_machine));
> + eu_static_assert (sizeof (((Elf32_Ehdr *) 0)->e_machine)
> + == sizeof (((Elf64_Ehdr *) 0)->e_machine));
> + eu_static_assert (offsetof (Elf, state.elf32.ehdr)
> + == offsetof (Elf, state.elf64.ehdr));
>
> /* Prefer taking the information from the ELF file. */
> if (elf == NULL)
> diff --git a/libelf/elf_begin.c b/libelf/elf_begin.c
> index d22f107dd5a0..0c9b95ddc2b1 100644
> --- a/libelf/elf_begin.c
> +++ b/libelf/elf_begin.c
> @@ -327,8 +327,8 @@ file_read_elf (int fildes, void *map_address, unsigned
> char *e_ident,
> return NULL;
>
> assert ((unsigned int) scncnt == scncnt);
> - assert (offsetof (struct Elf, state.elf32.scns)
> - == offsetof (struct Elf, state.elf64.scns));
> + eu_static_assert (offsetof (struct Elf, state.elf32.scns)
> + == offsetof (struct Elf, state.elf64.scns));
> elf->state.elf32.scns.cnt = scncnt;
> elf->state.elf32.scns.max = scnmax;
>
> @@ -1159,8 +1159,8 @@ write_file (int fd, Elf_Cmd cmd)
> result->state.elf.scnincr = NSCNSALLOC;
>
> /* We have allocated room for some sections. */
> - assert (offsetof (struct Elf, state.elf32.scns)
> - == offsetof (struct Elf, state.elf64.scns));
> + eu_static_assert (offsetof (struct Elf, state.elf32.scns)
> + == offsetof (struct Elf, state.elf64.scns));
> result->state.elf.scns_last = &result->state.elf32.scns;
> result->state.elf32.scns.max = NSCNSALLOC;
> }
> diff --git a/libelf/elf_clone.c b/libelf/elf_clone.c
> index e6fe4729e68f..ff96fc2156b8 100644
> --- a/libelf/elf_clone.c
> +++ b/libelf/elf_clone.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <stddef.h>
> #include "libelfP.h"
> #include "common.h"
> @@ -65,8 +64,8 @@ elf_clone (Elf *elf, Elf_Cmd cmd)
> retval->state.elf.scnincr = 10;
>
> /* We have allocated room for some sections. */
> - assert (offsetof (struct Elf, state.elf32.scns)
> - == offsetof (struct Elf, state.elf64.scns));
> + eu_static_assert (offsetof (struct Elf, state.elf32.scns)
> + == offsetof (struct Elf, state.elf64.scns));
> retval->state.elf.scns_last = &retval->state.elf32.scns;
> retval->state.elf32.scns.max = elf->state.elf32.scns.max;
>
> diff --git a/libelf/elf_getshdrstrndx.c b/libelf/elf_getshdrstrndx.c
> index 2391317bffe0..af9c3a1479fd 100644
> --- a/libelf/elf_getshdrstrndx.c
> +++ b/libelf/elf_getshdrstrndx.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <errno.h>
> #include <gelf.h>
> #include <stddef.h>
> @@ -58,14 +57,14 @@ elf_getshdrstrndx (Elf *elf, size_t *dst)
>
> /* We rely here on the fact that the `elf' element is a common prefix
> of `elf32' and `elf64'. */
> - assert (offsetof (struct Elf, state.elf.ehdr)
> - == offsetof (struct Elf, state.elf32.ehdr));
> - assert (sizeof (elf->state.elf.ehdr)
> - == sizeof (elf->state.elf32.ehdr));
> - assert (offsetof (struct Elf, state.elf.ehdr)
> - == offsetof (struct Elf, state.elf64.ehdr));
> - assert (sizeof (elf->state.elf.ehdr)
> - == sizeof (elf->state.elf64.ehdr));
> + eu_static_assert (offsetof (struct Elf, state.elf.ehdr)
> + == offsetof (struct Elf, state.elf32.ehdr));
> + eu_static_assert (sizeof (elf->state.elf.ehdr)
> + == sizeof (elf->state.elf32.ehdr));
> + eu_static_assert (offsetof (struct Elf, state.elf.ehdr)
> + == offsetof (struct Elf, state.elf64.ehdr));
> + eu_static_assert (sizeof (elf->state.elf.ehdr)
> + == sizeof (elf->state.elf64.ehdr));
>
> if (unlikely (elf->state.elf.ehdr == NULL))
> {
> diff --git a/libelf/elf_newscn.c b/libelf/elf_newscn.c
> index ec731f759de4..f7b20ab7cb2d 100644
> --- a/libelf/elf_newscn.c
> +++ b/libelf/elf_newscn.c
> @@ -51,12 +51,12 @@ elf_newscn (Elf *elf)
>
> /* We rely on the prefix of the `elf', `elf32', and `elf64' element
> being the same. */
> - assert (offsetof (Elf, state.elf.scns_last)
> - == offsetof (Elf, state.elf32.scns_last));
> - assert (offsetof (Elf, state.elf.scns_last)
> - == offsetof (Elf, state.elf64.scns_last));
> - assert (offsetof (Elf, state.elf32.scns)
> - == offsetof (Elf, state.elf64.scns));
> + eu_static_assert (offsetof (Elf, state.elf.scns_last)
> + == offsetof (Elf, state.elf32.scns_last));
> + eu_static_assert (offsetof (Elf, state.elf.scns_last)
> + == offsetof (Elf, state.elf64.scns_last));
> + eu_static_assert (offsetof (Elf, state.elf32.scns)
> + == offsetof (Elf, state.elf64.scns));
>
> rwlock_wrlock (elf->lock);
>
> diff --git a/libelf/gelf_getauxv.c b/libelf/gelf_getauxv.c
> index 1591be2a5686..405ec6465c83 100644
> --- a/libelf/gelf_getauxv.c
> +++ b/libelf/gelf_getauxv.c
> @@ -30,7 +30,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -84,7 +83,7 @@ gelf_getauxv (Elf_Data *data, int ndx, GElf_auxv_t *dst)
> else
> {
> /* If this is a 64 bit object it's easy. */
> - assert (sizeof (GElf_auxv_t) == sizeof (Elf64_auxv_t));
> + eu_static_assert (sizeof (GElf_auxv_t) == sizeof (Elf64_auxv_t));
>
> /* The data is already in the correct form. Just make sure the
> index is OK. */
> diff --git a/libelf/gelf_getdyn.c b/libelf/gelf_getdyn.c
> index a0090e147d54..32e75f9a888e 100644
> --- a/libelf/gelf_getdyn.c
> +++ b/libelf/gelf_getdyn.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -86,7 +85,7 @@ gelf_getdyn (Elf_Data *data, int ndx, GElf_Dyn *dst)
> else
> {
> /* If this is a 64 bit object it's easy. */
> - assert (sizeof (GElf_Dyn) == sizeof (Elf64_Dyn));
> + eu_static_assert (sizeof (GElf_Dyn) == sizeof (Elf64_Dyn));
>
> /* The data is already in the correct form. Just make sure the
> index is OK. */
> diff --git a/libelf/gelf_getlib.c b/libelf/gelf_getlib.c
> index a8ac47850c5b..9a6c24165ece 100644
> --- a/libelf/gelf_getlib.c
> +++ b/libelf/gelf_getlib.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -56,8 +55,8 @@ gelf_getlib (Elf_Data *data, int ndx, GElf_Lib *dst)
>
> /* The on disk format of Elf32_Lib and Elf64_Lib is identical. So
> we can simplify things significantly. */
> - assert (sizeof (GElf_Lib) == sizeof (Elf32_Lib));
> - assert (sizeof (GElf_Lib) == sizeof (Elf64_Lib));
> + eu_static_assert (sizeof (GElf_Lib) == sizeof (Elf32_Lib));
> + eu_static_assert (sizeof (GElf_Lib) == sizeof (Elf64_Lib));
>
> /* The data is already in the correct form. Just make sure the
> index is OK. */
> diff --git a/libelf/gelf_getsym.c b/libelf/gelf_getsym.c
> index 01534d2ce8fd..bc1e7b56bdc5 100644
> --- a/libelf/gelf_getsym.c
> +++ b/libelf/gelf_getsym.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -91,7 +90,7 @@ gelf_getsym (Elf_Data *data, int ndx, GElf_Sym *dst)
> else
> {
> /* If this is a 64 bit object it's easy. */
> - assert (sizeof (GElf_Sym) == sizeof (Elf64_Sym));
> + eu_static_assert (sizeof (GElf_Sym) == sizeof (Elf64_Sym));
>
> /* The data is already in the correct form. Just make sure the
> index is OK. */
> diff --git a/libelf/gelf_getsyminfo.c b/libelf/gelf_getsyminfo.c
> index 8360ed387ad0..d1ec9e7942c9 100644
> --- a/libelf/gelf_getsyminfo.c
> +++ b/libelf/gelf_getsyminfo.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -53,8 +52,8 @@ gelf_getsyminfo (Elf_Data *data, int ndx, GElf_Syminfo *dst)
> }
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Syminfo) == sizeof (Elf32_Syminfo));
> - assert (sizeof (GElf_Syminfo) == sizeof (Elf64_Syminfo));
> + eu_static_assert (sizeof (GElf_Syminfo) == sizeof (Elf32_Syminfo));
> + eu_static_assert (sizeof (GElf_Syminfo) == sizeof (Elf64_Syminfo));
>
> rwlock_rdlock (((Elf_Data_Scn *) data)->s->elf->lock);
>
> diff --git a/libelf/gelf_getsymshndx.c b/libelf/gelf_getsymshndx.c
> index 17c90fc6d082..534502e34f7a 100644
> --- a/libelf/gelf_getsymshndx.c
> +++ b/libelf/gelf_getsymshndx.c
> @@ -32,7 +32,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -110,7 +109,7 @@ gelf_getsymshndx (Elf_Data *symdata, Elf_Data *shndxdata,
> int ndx,
> else
> {
> /* If this is a 64 bit object it's easy. */
> - assert (sizeof (GElf_Sym) == sizeof (Elf64_Sym));
> + eu_static_assert (sizeof (GElf_Sym) == sizeof (Elf64_Sym));
>
> /* The data is already in the correct form. Just make sure the
> index is OK. */
> diff --git a/libelf/gelf_getverdaux.c b/libelf/gelf_getverdaux.c
> index 739a7657d850..099c6612f5ad 100644
> --- a/libelf/gelf_getverdaux.c
> +++ b/libelf/gelf_getverdaux.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -54,8 +53,8 @@ gelf_getverdaux (Elf_Data *data, int offset, GElf_Verdaux
> *dst)
>
> /* It's easy to handle this type. It has the same size for 32 and
> 64 bit objects. */
> - assert (sizeof (GElf_Verdaux) == sizeof (Elf32_Verdaux));
> - assert (sizeof (GElf_Verdaux) == sizeof (Elf64_Verdaux));
> + eu_static_assert (sizeof (GElf_Verdaux) == sizeof (Elf32_Verdaux));
> + eu_static_assert (sizeof (GElf_Verdaux) == sizeof (Elf64_Verdaux));
>
> rwlock_rdlock (((Elf_Data_Scn *) data)->s->elf->lock);
>
> diff --git a/libelf/gelf_getverdef.c b/libelf/gelf_getverdef.c
> index 651f4fadc1cb..85be7caf4fa3 100644
> --- a/libelf/gelf_getverdef.c
> +++ b/libelf/gelf_getverdef.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -54,8 +53,8 @@ gelf_getverdef (Elf_Data *data, int offset, GElf_Verdef
> *dst)
>
> /* It's easy to handle this type. It has the same size for 32 and
> 64 bit objects. */
> - assert (sizeof (GElf_Verdef) == sizeof (Elf32_Verdef));
> - assert (sizeof (GElf_Verdef) == sizeof (Elf64_Verdef));
> + eu_static_assert (sizeof (GElf_Verdef) == sizeof (Elf32_Verdef));
> + eu_static_assert (sizeof (GElf_Verdef) == sizeof (Elf64_Verdef));
>
> rwlock_rdlock (((Elf_Data_Scn *) data)->s->elf->lock);
>
> diff --git a/libelf/gelf_getvernaux.c b/libelf/gelf_getvernaux.c
> index e47fb0a22753..234543367606 100644
> --- a/libelf/gelf_getvernaux.c
> +++ b/libelf/gelf_getvernaux.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -55,10 +54,10 @@ gelf_getvernaux (Elf_Data *data, int offset, GElf_Vernaux
> *dst)
> /* It's easy to handle this type. It has the same size for 32 and
> 64 bit objects. And fortunately the `ElfXXX_Vernaux' records
> also have the same size. */
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Verneed));
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Verneed));
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Vernaux));
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Vernaux));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Verneed));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Verneed));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Vernaux));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Vernaux));
>
> rwlock_rdlock (((Elf_Data_Scn *) data)->s->elf->lock);
>
> diff --git a/libelf/gelf_getverneed.c b/libelf/gelf_getverneed.c
> index c1f5d3409fca..ff3743ea3451 100644
> --- a/libelf/gelf_getverneed.c
> +++ b/libelf/gelf_getverneed.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -55,10 +54,10 @@ gelf_getverneed (Elf_Data *data, int offset, GElf_Verneed
> *dst)
> /* It's easy to handle this type. It has the same size for 32 and
> 64 bit objects. And fortunately the `ElfXXX_Vernaux' records
> also have the same size. */
> - assert (sizeof (GElf_Verneed) == sizeof (Elf32_Verneed));
> - assert (sizeof (GElf_Verneed) == sizeof (Elf64_Verneed));
> - assert (sizeof (GElf_Verneed) == sizeof (Elf32_Vernaux));
> - assert (sizeof (GElf_Verneed) == sizeof (Elf64_Vernaux));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf32_Verneed));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf64_Verneed));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf32_Vernaux));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf64_Vernaux));
>
> rwlock_rdlock (((Elf_Data_Scn *) data)->s->elf->lock);
>
> diff --git a/libelf/gelf_getversym.c b/libelf/gelf_getversym.c
> index 68d23c72e9d1..aa2c0a0904e1 100644
> --- a/libelf/gelf_getversym.c
> +++ b/libelf/gelf_getversym.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -61,8 +60,8 @@ gelf_getversym (Elf_Data *data, int ndx, GElf_Versym *dst)
>
> /* It's easy to handle this type. It has the same size for 32 and
> 64 bit objects. */
> - assert (sizeof (GElf_Versym) == sizeof (Elf32_Versym));
> - assert (sizeof (GElf_Versym) == sizeof (Elf64_Versym));
> + eu_static_assert (sizeof (GElf_Versym) == sizeof (Elf32_Versym));
> + eu_static_assert (sizeof (GElf_Versym) == sizeof (Elf64_Versym));
>
> rwlock_rdlock (scn->elf->lock);
>
> diff --git a/libelf/gelf_update_syminfo.c b/libelf/gelf_update_syminfo.c
> index 6f7f30255a4f..a471e42983a9 100644
> --- a/libelf/gelf_update_syminfo.c
> +++ b/libelf/gelf_update_syminfo.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <stdlib.h>
>
> @@ -56,8 +55,8 @@ gelf_update_syminfo (Elf_Data *data, int ndx, GElf_Syminfo
> *src)
> }
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Syminfo) == sizeof (Elf32_Syminfo));
> - assert (sizeof (GElf_Syminfo) == sizeof (Elf64_Syminfo));
> + eu_static_assert (sizeof (GElf_Syminfo) == sizeof (Elf32_Syminfo));
> + eu_static_assert (sizeof (GElf_Syminfo) == sizeof (Elf64_Syminfo));
>
> scn = data_scn->s;
> rwlock_wrlock (scn->elf->lock);
> diff --git a/libelf/gelf_update_verdaux.c b/libelf/gelf_update_verdaux.c
> index f3554fdcb6e4..9f4a43fad275 100644
> --- a/libelf/gelf_update_verdaux.c
> +++ b/libelf/gelf_update_verdaux.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -47,8 +46,8 @@ gelf_update_verdaux (Elf_Data *data, int offset,
> GElf_Verdaux *src)
> return 0;
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Verdaux) == sizeof (Elf32_Verdaux));
> - assert (sizeof (GElf_Verdaux) == sizeof (Elf64_Verdaux));
> + eu_static_assert (sizeof (GElf_Verdaux) == sizeof (Elf32_Verdaux));
> + eu_static_assert (sizeof (GElf_Verdaux) == sizeof (Elf64_Verdaux));
>
> /* Check whether we have to resize the data buffer. */
> if (unlikely (offset < 0)
> diff --git a/libelf/gelf_update_verdef.c b/libelf/gelf_update_verdef.c
> index adb5db146a7a..bd224bdba6f4 100644
> --- a/libelf/gelf_update_verdef.c
> +++ b/libelf/gelf_update_verdef.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -47,8 +46,8 @@ gelf_update_verdef (Elf_Data *data, int offset, GElf_Verdef
> *src)
> return 0;
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Verdef) == sizeof (Elf32_Verdef));
> - assert (sizeof (GElf_Verdef) == sizeof (Elf64_Verdef));
> + eu_static_assert (sizeof (GElf_Verdef) == sizeof (Elf32_Verdef));
> + eu_static_assert (sizeof (GElf_Verdef) == sizeof (Elf64_Verdef));
>
> /* Check whether we have to resize the data buffer. */
> if (unlikely (offset < 0)
> diff --git a/libelf/gelf_update_vernaux.c b/libelf/gelf_update_vernaux.c
> index 854afabbca45..f60429a65b88 100644
> --- a/libelf/gelf_update_vernaux.c
> +++ b/libelf/gelf_update_vernaux.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -47,8 +46,8 @@ gelf_update_vernaux (Elf_Data *data, int offset,
> GElf_Vernaux *src)
> return 0;
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Vernaux));
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Vernaux));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Vernaux));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Vernaux));
>
> /* Check whether we have to resize the data buffer. */
> if (unlikely (offset < 0)
> diff --git a/libelf/gelf_update_verneed.c b/libelf/gelf_update_verneed.c
> index bf5af5a30568..43338a8f76d8 100644
> --- a/libelf/gelf_update_verneed.c
> +++ b/libelf/gelf_update_verneed.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <string.h>
>
> @@ -47,8 +46,8 @@ gelf_update_verneed (Elf_Data *data, int offset,
> GElf_Verneed *src)
> return 0;
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Verneed) == sizeof (Elf32_Verneed));
> - assert (sizeof (GElf_Verneed) == sizeof (Elf64_Verneed));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf32_Verneed));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf64_Verneed));
>
> /* Check whether we have to resize the data buffer. */
> if (unlikely (offset < 0)
> diff --git a/libelf/gelf_update_versym.c b/libelf/gelf_update_versym.c
> index 9949dffb03e0..5dc46222e930 100644
> --- a/libelf/gelf_update_versym.c
> +++ b/libelf/gelf_update_versym.c
> @@ -31,7 +31,6 @@
> # include <config.h>
> #endif
>
> -#include <assert.h>
> #include <gelf.h>
> #include <stdlib.h>
>
> @@ -47,8 +46,8 @@ gelf_update_versym (Elf_Data *data, int ndx, GElf_Versym
> *src)
> return 0;
>
> /* The types for 32 and 64 bit are the same. Lucky us. */
> - assert (sizeof (GElf_Versym) == sizeof (Elf32_Versym));
> - assert (sizeof (GElf_Versym) == sizeof (Elf64_Versym));
> + eu_static_assert (sizeof (GElf_Versym) == sizeof (Elf32_Versym));
> + eu_static_assert (sizeof (GElf_Versym) == sizeof (Elf64_Versym));
>
> /* Check whether we have to resize the data buffer. */
> if (INVALID_NDX (ndx, GElf_Versym, &data_scn->d))
> diff --git a/libelf/gnuhash_xlate.h b/libelf/gnuhash_xlate.h
> index 3a00ae0ae18b..cf9d4b57b053 100644
> --- a/libelf/gnuhash_xlate.h
> +++ b/libelf/gnuhash_xlate.h
> @@ -28,7 +28,6 @@
> the GNU Lesser General Public License along with this program. If
> not, see <http://www.gnu.org/licenses/>. */
>
> -#include <assert.h>
> #include <gelf.h>
>
> #include "libelfP.h"
> diff --git a/libelf/note_xlate.h b/libelf/note_xlate.h
> index 7e2784b0587f..dc3a35652157 100644
> --- a/libelf/note_xlate.h
> +++ b/libelf/note_xlate.h
> @@ -32,7 +32,7 @@ elf_cvt_note (void *dest, const void *src, size_t len, int
> encode,
> {
> /* Note that the header is always the same size, but the padding
> differs for GNU Property notes. */
> - assert (sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr));
> + eu_static_assert (sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr));
>
> while (len >= sizeof (Elf32_Nhdr))
> {
> diff --git a/libelf/version_xlate.h b/libelf/version_xlate.h
> index 97f3b7303e16..f44cb0cef8c2 100644
> --- a/libelf/version_xlate.h
> +++ b/libelf/version_xlate.h
> @@ -28,7 +28,6 @@
> the GNU Lesser General Public License along with this program. If
> not, see <http://www.gnu.org/licenses/>. */
>
> -#include <assert.h>
> #include <gelf.h>
>
> #include "libelfP.h"
> @@ -48,10 +47,10 @@ elf_cvt_Verdef (void *dest, const void *src, size_t len,
> int encode)
> GElf_Verdef *dsrc;
>
> /* We rely on the types being all the same size. */
> - assert (sizeof (GElf_Verdef) == sizeof (Elf32_Verdef));
> - assert (sizeof (GElf_Verdaux) == sizeof (Elf32_Verdaux));
> - assert (sizeof (GElf_Verdef) == sizeof (Elf64_Verdef));
> - assert (sizeof (GElf_Verdaux) == sizeof (Elf64_Verdaux));
> + eu_static_assert (sizeof (GElf_Verdef) == sizeof (Elf32_Verdef));
> + eu_static_assert (sizeof (GElf_Verdaux) == sizeof (Elf32_Verdaux));
> + eu_static_assert (sizeof (GElf_Verdef) == sizeof (Elf64_Verdef));
> + eu_static_assert (sizeof (GElf_Verdaux) == sizeof (Elf64_Verdaux));
>
> if (len == 0)
> return;
> @@ -171,10 +170,10 @@ elf_cvt_Verneed (void *dest, const void *src, size_t
> len, int encode)
> GElf_Verneed *nsrc;
>
> /* We rely on the types being all the same size. */
> - assert (sizeof (GElf_Verneed) == sizeof (Elf32_Verneed));
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Vernaux));
> - assert (sizeof (GElf_Verneed) == sizeof (Elf64_Verneed));
> - assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Vernaux));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf32_Verneed));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf32_Vernaux));
> + eu_static_assert (sizeof (GElf_Verneed) == sizeof (Elf64_Verneed));
> + eu_static_assert (sizeof (GElf_Vernaux) == sizeof (Elf64_Vernaux));
>
> if (len == 0)
> return;
> diff --git a/src/arlib.c b/src/arlib.c
> index b8f89ba7df87..80344389da36 100644
> --- a/src/arlib.c
> +++ b/src/arlib.c
> @@ -64,7 +64,7 @@ arlib_init (void)
> (arlib_deterministic_output ? 0
> : (long long int) time (NULL)));
> memcpy (ar_hdr.ar_date, tmpbuf, s);
> - assert ((sizeof (struct ar_hdr) % sizeof (uint32_t)) == 0);
> + eu_static_assert ((sizeof (struct ar_hdr) % sizeof (uint32_t)) == 0);
>
> /* Note the string for the ar_uid and ar_gid cases is longer than
> necessary. This does not matter since we copy only as much as
> @@ -81,7 +81,7 @@ arlib_init (void)
> /* The first word in the offset table specifies the size. Create
> such an entry now. The real value will be filled-in later. For
> all supported platforms the following is true. */
> - assert (sizeof (uint32_t) == sizeof (int));
> + eu_static_assert (sizeof (uint32_t) == sizeof (int));
> obstack_int_grow (&symtab.symsoffob, 0);
>
> /* The long name obstack also gets its archive header. As above,
> @@ -194,7 +194,7 @@ void
> arlib_add_symref (const char *symname, off_t symoff)
> {
> /* For all supported platforms the following is true. */
> - assert (sizeof (uint32_t) == sizeof (int));
> + eu_static_assert (sizeof (uint32_t) == sizeof (int));
> obstack_int_grow (&symtab.symsoffob, (int) le_bswap_32 (symoff));
>
> size_t symname_len = strlen (symname) + 1;
> diff --git a/src/strip.c b/src/strip.c
> index 8d2bb7a959f0..20cc8a22e9ae 100644
> --- a/src/strip.c
> +++ b/src/strip.c
> @@ -2600,10 +2600,12 @@ while computing checksum for debug information"));
>
> if (newehdr->e_ident[EI_CLASS] == ELFCLASS32)
> {
> - assert (offsetof (Elf32_Ehdr, e_shentsize) + sizeof (Elf32_Half)
> - == offsetof (Elf32_Ehdr, e_shnum));
> - assert (offsetof (Elf32_Ehdr, e_shnum) + sizeof (Elf32_Half)
> - == offsetof (Elf32_Ehdr, e_shstrndx));
> + eu_static_assert (offsetof (Elf32_Ehdr, e_shentsize)
> + + sizeof (Elf32_Half)
> + == offsetof (Elf32_Ehdr, e_shnum));
> + eu_static_assert (offsetof (Elf32_Ehdr, e_shnum)
> + + sizeof (Elf32_Half)
> + == offsetof (Elf32_Ehdr, e_shstrndx));
> const Elf32_Off zero_off = 0;
> const Elf32_Half zero[3] = { 0, 0, SHN_UNDEF };
> if (pwrite_retry (fd, &zero_off, sizeof zero_off,
> @@ -2620,10 +2622,12 @@ while computing checksum for debug information"));
> }
> else
> {
> - assert (offsetof (Elf64_Ehdr, e_shentsize) + sizeof (Elf64_Half)
> - == offsetof (Elf64_Ehdr, e_shnum));
> - assert (offsetof (Elf64_Ehdr, e_shnum) + sizeof (Elf64_Half)
> - == offsetof (Elf64_Ehdr, e_shstrndx));
> + eu_static_assert (offsetof (Elf64_Ehdr, e_shentsize)
> + + sizeof (Elf64_Half)
> + == offsetof (Elf64_Ehdr, e_shnum));
> + eu_static_assert (offsetof (Elf64_Ehdr, e_shnum)
> + +sizeof (Elf64_Half)
> + == offsetof (Elf64_Ehdr, e_shstrndx));
> const Elf64_Off zero_off = 0;
> const Elf64_Half zero[3] = { 0, 0, SHN_UNDEF };
> if (pwrite_retry (fd, &zero_off, sizeof zero_off,
> diff --git a/src/unstrip.c b/src/unstrip.c
> index 6c2a98ef96f2..5585b0e25101 100644
> --- a/src/unstrip.c
> +++ b/src/unstrip.c
> @@ -570,8 +570,8 @@ adjust_relocs (Elf_Scn *outscn, Elf_Scn *inscn, const
> GElf_Shdr *shdr,
>
> /* We don't bother using gelf_update_versym because there is
> really no conversion to be done. */
> - assert (sizeof (Elf32_Versym) == sizeof (GElf_Versym));
> - assert (sizeof (Elf64_Versym) == sizeof (GElf_Versym));
> + eu_static_assert (sizeof (Elf32_Versym) == sizeof (GElf_Versym));
> + eu_static_assert (sizeof (Elf64_Versym) == sizeof (GElf_Versym));
> GElf_Versym *versym = xcalloc (nent, sizeof versym[0]);
>
> for (size_t i = 1; i < onent; ++i)
> --
> 2.53.0
>
