/src/libbpf/elfutils/libelf/abstract.h

Source (jump to first uncovered line)
/* Abstract description of component ELF types.
   Copyright (C) 1998, 1999, 2000, 2002, 2004, 2007, 2015 Red Hat, Inc.
   This file is part of elfutils.
   Written by Ulrich Drepper <drepper@redhat.com>, 1998.

   This file is free software; you can redistribute it and/or modify
   it under the terms of either

     * the GNU Lesser General Public License as published by the Free
       Software Foundation; either version 3 of the License, or (at
       your option) any later version

   or

     * the GNU General Public License as published by the Free
       Software Foundation; either version 2 of the License, or (at
       your option) any later version

   or both in parallel, as here.

   elfutils is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received copies of the GNU General Public License and
   the GNU Lesser General Public License along with this program.  If
   not, see <http://www.gnu.org/licenses/>.  */

/* ELF header.  */
#define Ehdr(Bits, Ext) \
START (Bits, Ehdr, Ext##Ehdr)                  \
  TYPE_EXTRA (unsigned char e_ident[EI_NIDENT];)            \
  TYPE_XLATE (memmove (tdest->e_ident, tsrc->e_ident, EI_NIDENT);)        \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_type)             \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_machine)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), e_version)              \
  TYPE_NAME (ElfW2(Bits, Ext##Addr), e_entry)              \
  TYPE_NAME (ElfW2(Bits, Ext##Off), e_phoff)             \
  TYPE_NAME (ElfW2(Bits, Ext##Off), e_shoff)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), e_flags)              \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_ehsize)             \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_phentsize)            \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_phnum)              \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_shentsize)            \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_shnum)              \
  TYPE_NAME (ElfW2(Bits, Ext##Half), e_shstrndx)           \
END (Bits, Ext##Ehdr)

#define Ehdr32(Ext) \
  Ehdr(32, Ext)
#define Ehdr64(Ext) \
  Ehdr(64, Ext)


/* Program header.  */
#define Phdr32(Ext) \
START (32, Phdr, Ext##Phdr)                  \
  TYPE_NAME (ElfW2(32, Ext##Word), p_type)             \
  TYPE_NAME (ElfW2(32, Ext##Off), p_offset)              \
  TYPE_NAME (ElfW2(32, Ext##Addr), p_vaddr)              \
  TYPE_NAME (ElfW2(32, Ext##Addr), p_paddr)              \
  TYPE_NAME (ElfW2(32, Ext##Word), p_filesz)             \
  TYPE_NAME (ElfW2(32, Ext##Word), p_memsz)              \
  TYPE_NAME (ElfW2(32, Ext##Word), p_flags)              \
  TYPE_NAME (ElfW2(32, Ext##Word), p_align)              \
END (32, Ext##Phdr)
#define Phdr64(Ext) \
START (64, Phdr, Ext##Phdr)                  \
  TYPE_NAME (ElfW2(64, Ext##Word), p_type)             \
  TYPE_NAME (ElfW2(64, Ext##Word), p_flags)              \
  TYPE_NAME (ElfW2(64, Ext##Off), p_offset)              \
  TYPE_NAME (ElfW2(64, Ext##Addr), p_vaddr)              \
  TYPE_NAME (ElfW2(64, Ext##Addr), p_paddr)              \
  TYPE_NAME (ElfW2(64, Ext##Xword), p_filesz)              \
  TYPE_NAME (ElfW2(64, Ext##Xword), p_memsz)             \
  TYPE_NAME (ElfW2(64, Ext##Xword), p_align)             \
END (64, Ext##Phdr)


/* Section header.  */
#define Shdr32(Ext) \
START (32, Shdr, Ext##Shdr)                  \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_name)              \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_type)              \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_flags)             \
  TYPE_NAME (ElfW2(32, Ext##Addr), sh_addr)              \
  TYPE_NAME (ElfW2(32, Ext##Off), sh_offset)             \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_size)              \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_link)              \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_info)              \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_addralign)           \
  TYPE_NAME (ElfW2(32, Ext##Word), sh_entsize)             \
END (32, Ext##Shdr)
#define Shdr64(Ext) \
START (64, Shdr, Ext##Shdr)                  \
  TYPE_NAME (ElfW2(64, Ext##Word), sh_name)              \
  TYPE_NAME (ElfW2(64, Ext##Word), sh_type)              \
  TYPE_NAME (ElfW2(64, Ext##Xword), sh_flags)              \
  TYPE_NAME (ElfW2(64, Ext##Addr), sh_addr)              \
  TYPE_NAME (ElfW2(64, Ext##Off), sh_offset)             \
  TYPE_NAME (ElfW2(64, Ext##Xword), sh_size)             \
  TYPE_NAME (ElfW2(64, Ext##Word), sh_link)              \
  TYPE_NAME (ElfW2(64, Ext##Word), sh_info)              \
  TYPE_NAME (ElfW2(64, Ext##Xword), sh_addralign)            \
  TYPE_NAME (ElfW2(64, Ext##Xword), sh_entsize)              \
END (64, Ext##Shdr)


/* Symbol table.  */
#define Sym32(Ext) \
START (32, Sym, Ext##Sym)                  \
  TYPE_NAME (ElfW2(32, Ext##Word), st_name)              \
  TYPE_NAME (ElfW2(32, Ext##Addr), st_value)             \
  TYPE_NAME (ElfW2(32, Ext##Word), st_size)              \
  TYPE_EXTRA (unsigned char st_info;)               \
  TYPE_XLATE (tdest->st_info = tsrc->st_info;)              \
  TYPE_EXTRA (unsigned char st_other;)                \
  TYPE_XLATE (tdest->st_other = tsrc->st_other;)            \
  TYPE_NAME (ElfW2(32, Ext##Half), st_shndx)             \
END (32, Ext##Sym)
#define Sym64(Ext) \
START (64, Sym, Ext##Sym)                  \
  TYPE_NAME (ElfW2(64, Ext##Word), st_name)              \
  TYPE_EXTRA (unsigned char st_info;)               \
  TYPE_XLATE (tdest->st_info = tsrc->st_info;)              \
  TYPE_EXTRA (unsigned char st_other;)                \
  TYPE_XLATE (tdest->st_other = tsrc->st_other;)            \
  TYPE_NAME (ElfW2(64, Ext##Half), st_shndx)             \
  TYPE_NAME (ElfW2(64, Ext##Addr), st_value)             \
  TYPE_NAME (ElfW2(64, Ext##Xword), st_size)             \
END (64, Ext##Sym)


/* Relocation.  */
#define Rel32(Ext) \
START (32, Rel, Ext##Rel)                  \
  TYPE_NAME (ElfW2(32, Ext##Addr), r_offset)             \
  TYPE_NAME (ElfW2(32, Ext##Word), r_info)             \
END (32, Ext##Rel)
#define Rel64(Ext) \
START (64, Rel, Ext##Rel)                  \
  TYPE_NAME (ElfW2(64, Ext##Addr), r_offset)             \
  TYPE_NAME (ElfW2(64, Ext##Xword), r_info)              \
END (64, Ext##Rel)

#define Rela32(Ext) \
START (32, Rela, Ext##Rela)                  \
  TYPE_NAME (ElfW2(32, Ext##Addr), r_offset)             \
  TYPE_NAME (ElfW2(32, Ext##Word), r_info)             \
  TYPE_NAME (ElfW2(32, Ext##Sword), r_addend)              \
END (32, Ext##Rela)
#define Rela64(Ext) \
START (64, Rela, Ext##Rela)                  \
  TYPE_NAME (ElfW2(64, Ext##Addr), r_offset)             \
  TYPE_NAME (ElfW2(64, Ext##Xword), r_info)              \
  TYPE_NAME (ElfW2(64, Ext##Sxword), r_addend)             \
END (64, Ext##Rela)


/* Note entry header.  */
#define Note(Bits, Ext) \
START (Bits, Nhdr, Ext##Nhdr)                  \
  TYPE_NAME (ElfW2(Bits, Ext##Word), n_namesz)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), n_descsz)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), n_type)             \
END (Bits, Ext##Nhdr)

#define Note32(Ext) \
  Note (32, Ext)
#define Note64(Ext) \
  Note (64, Ext)


/* Dynamic section data.  */
#define Dyn32(Ext) \
START (32, Dyn, Ext##Dyn)                  \
  TYPE_NAME (ElfW2(32, Ext##Sword), d_tag)             \
  TYPE_EXTRA (union {)                    \
  TYPE_EXTRA (ElfW2(32, Ext##Word) d_val;)              \
  TYPE_EXTRA (ElfW2(32, Ext##Addr) d_ptr;)              \
  TYPE_XLATE (Elf32_cvt_Addr1 (&tdest->d_un.d_val, &tsrc->d_un.d_val);)       \
  TYPE_EXTRA (ElfW2(32, Ext##Off) d_off;)             \
  TYPE_EXTRA (} d_un;)                    \
END (32, Ext##Dyn)
#define Dyn64(Ext) \
START (64, Dyn, Ext##Dyn)                  \
  TYPE_NAME (ElfW2(64, Ext##Xword), d_tag)             \
  TYPE_EXTRA (union {)                    \
  TYPE_EXTRA (ElfW2(64, Ext##Xword) d_val;)             \
  TYPE_EXTRA (ElfW2(64, Ext##Addr) d_ptr;)              \
  TYPE_XLATE (Elf64_cvt_Addr1 (&tdest->d_un.d_val, &tsrc->d_un.d_val);)       \
  TYPE_EXTRA (} d_un;)                    \
END (64, Ext##Dyn)


#ifndef GENERATE_CONVERSION
/* Version definitions.  */
# define Verdef(Bits, Ext) \
START (Bits, Verdef, Ext##Verdef)               \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vd_version)            \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vd_flags)              \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vd_ndx)              \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vd_cnt)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vd_hash)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vd_aux)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vd_next)             \
END (Bits, Ext##Verdef)

# define Verdef32(Ext) \
  Verdef (32, Ext)
# define Verdef64(Ext) \
  Verdef (64, Ext)

# define Verdaux(Bits, Ext) \
START (Bits, Verdaux, Ext##Verdaux)               \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vda_name)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vda_next)              \
END (Bits, Ext##Verdaux)

# define Verdaux32(Ext) \
  Verdaux (32, Ext)
# define Verdaux64(Ext) \
  Verdaux (64, Ext)

/* Required versions.  */
# define Verneed(Bits, Ext) \
START (Bits, Verneed, Ext##Verneed)               \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vn_version)            \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vn_cnt)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vn_file)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vn_aux)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vn_next)             \
END (Bits, Ext##Verneed)

# define Verneed32(Ext) \
  Verneed (32, Ext)
# define Verneed64(Ext) \
  Verneed (64, Ext)

# define Vernaux(Bits, Ext) \
START (Bits, Vernaux, Ext##Vernaux)               \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vna_hash)              \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vna_flags)             \
  TYPE_NAME (ElfW2(Bits, Ext##Half), vna_other)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vna_name)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), vna_next)              \
END (Bits, Ext##Vernaux)

# define Vernaux32(Ext) \
  Vernaux (32, Ext)
# define Vernaux64(Ext) \
  Vernaux (64, Ext)
#endif

/* Symbol information.  */
#define Syminfo(Bits, Ext) \
START (Bits, Syminfo, Ext##Syminfo)                \
  TYPE_NAME (ElfW2(Bits, Ext##Half), si_boundto)           \
  TYPE_NAME (ElfW2(Bits, Ext##Half), si_flags)             \
END (Bits, Ext##Syminfo)

#define Syminfo32(Ext) \
  Syminfo (32, Ext)
#define Syminfo64(Ext) \
  Syminfo (64, Ext)

/* Move information.  */
#define Move(Bits, Ext) \
START (Bits, Move, Ext##Move)                  \
  TYPE_NAME (ElfW2(Bits, Ext##Xword), m_value)             \
  TYPE_NAME (ElfW2(Bits, Ext##Xword), m_info)              \
  TYPE_NAME (ElfW2(Bits, Ext##Xword), m_poffset)           \
  TYPE_NAME (ElfW2(Bits, Ext##Half), m_repeat)             \
  TYPE_NAME (ElfW2(Bits, Ext##Half), m_stride)             \
END (Bits, Ext##Move)

#define Move32(Ext) \
  Move (32, Ext)
#define Move64(Ext) \
  Move (64, Ext)

#define Lib(Bits, Ext) \
START (Bits, Lib, Ext##Lib)                  \
  TYPE_NAME (ElfW2(Bits, Ext##Word), l_name)             \
  TYPE_NAME (ElfW2(Bits, Ext##Word), l_time_stamp)           \
  TYPE_NAME (ElfW2(Bits, Ext##Word), l_checksum)           \
  TYPE_NAME (ElfW2(Bits, Ext##Word), l_version)              \
  TYPE_NAME (ElfW2(Bits, Ext##Word), l_flags)              \
END (Bits, Ext##Lib)

#define Lib32(Ext) \
  Lib (32, Ext)
#define Lib64(Ext) \
  Lib (64, Ext)

#define auxv_t32(Ext) \
START (32, auxv_t, Ext##auxv_t)                  \
  TYPE_NAME (ElfW2(32, Ext##Word), a_type)             \
  TYPE_EXTRA (union {)                    \
  TYPE_EXTRA (ElfW2(32, Ext##Word) a_val;)              \
  TYPE_XLATE (Elf32_cvt_Addr1 (&tdest->a_un.a_val, &tsrc->a_un.a_val);)       \
  TYPE_EXTRA (} a_un;)                    \
END (32, Ext##auxv_t)
#define auxv_t64(Ext) \
START (64, auxv_t, Ext##auxv_t)                  \
  TYPE_NAME (ElfW2(64, Ext##Xword), a_type)              \
  TYPE_EXTRA (union {)                    \
  TYPE_EXTRA (ElfW2(64, Ext##Xword) a_val;)             \
  TYPE_XLATE (Elf64_cvt_Addr1 (&tdest->a_un.a_val, &tsrc->a_un.a_val);)       \
  TYPE_EXTRA (} a_un;)                    \
END (64, Ext##auxv_t)

/* Note that there is actual compression data right after the Chdr.
   So we also have a separate conversion function for the whole
   section.  */
#define Chdr32(Ext) \
START (32, Chdr, Ext##Chdr)            \
  TYPE_NAME (ElfW2(32, Ext##Word), ch_type)        \
  TYPE_NAME (ElfW2(32, Ext##Word), ch_size)        \
  TYPE_NAME (ElfW2(32, Ext##Word), ch_addralign)     \
END (32, Ext##Chdr)

#define Chdr64(Ext) \
START (64, Chdr, Ext##Chdr)            \
  TYPE_NAME (ElfW2(64, Ext##Word), ch_type)        \
  TYPE_NAME (ElfW2(64, Ext##Word), ch_reserved)        \
  TYPE_NAME (ElfW2(64, Ext##Xword), ch_size)       \
  TYPE_NAME (ElfW2(64, Ext##Xword), ch_addralign)      \
END (64, Ext##Chdr)

Coverage Report

Created: 2024-07-17 06:29

Line	Count	Source (jump to first uncovered line)
1		/* Abstract description of component ELF types.
2		Copyright (C) 1998, 1999, 2000, 2002, 2004, 2007, 2015 Red Hat, Inc.
3		This file is part of elfutils.
4		Written by Ulrich Drepper <drepper@redhat.com>, 1998.
5
6		This file is free software; you can redistribute it and/or modify
7		it under the terms of either
8
9		* the GNU Lesser General Public License as published by the Free
10		Software Foundation; either version 3 of the License, or (at
11		your option) any later version
12
13		or
14
15		* the GNU General Public License as published by the Free
16		Software Foundation; either version 2 of the License, or (at
17		your option) any later version
18
19		or both in parallel, as here.
20
21		elfutils is distributed in the hope that it will be useful, but
22		WITHOUT ANY WARRANTY; without even the implied warranty of
23		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24		General Public License for more details.
25
26		You should have received copies of the GNU General Public License and
27		the GNU Lesser General Public License along with this program. If
28		not, see <http://www.gnu.org/licenses/>. */
29
30		/* ELF header. */
31	0	#define Ehdr(Bits, Ext) \
32	0	START (Bits, Ehdr, Ext##Ehdr) \
33	0	TYPE_EXTRA (unsigned char e_ident[EI_NIDENT];) \
34	0	TYPE_XLATE (memmove (tdest->e_ident, tsrc->e_ident, EI_NIDENT);) \
35	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_type) \
36	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_machine) \
37	0	TYPE_NAME (ElfW2(Bits, Ext##Word), e_version) \
38	0	TYPE_NAME (ElfW2(Bits, Ext##Addr), e_entry) \
39	0	TYPE_NAME (ElfW2(Bits, Ext##Off), e_phoff) \
40	0	TYPE_NAME (ElfW2(Bits, Ext##Off), e_shoff) \
41	0	TYPE_NAME (ElfW2(Bits, Ext##Word), e_flags) \
42	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_ehsize) \
43	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_phentsize) \
44	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_phnum) \
45	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_shentsize) \
46	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_shnum) \
47	0	TYPE_NAME (ElfW2(Bits, Ext##Half), e_shstrndx) \
48	0	END (Bits, Ext##Ehdr) Unexecuted instantiation: gelf_xlate.c:Elf32_cvt_Ehdr Unexecuted instantiation: gelf_xlate.c:Elf64_cvt_Ehdr
49
50		#define Ehdr32(Ext) \
51		Ehdr(32, Ext)
52		#define Ehdr64(Ext) \
53		Ehdr(64, Ext)
54
55
56		/* Program header. */
57	0	#define Phdr32(Ext) \
58	0	START (32, Phdr, Ext##Phdr) \
59	0	TYPE_NAME (ElfW2(32, Ext##Word), p_type) \
60	0	TYPE_NAME (ElfW2(32, Ext##Off), p_offset) \
61	0	TYPE_NAME (ElfW2(32, Ext##Addr), p_vaddr) \
62	0	TYPE_NAME (ElfW2(32, Ext##Addr), p_paddr) \
63	0	TYPE_NAME (ElfW2(32, Ext##Word), p_filesz) \
64	0	TYPE_NAME (ElfW2(32, Ext##Word), p_memsz) \
65	0	TYPE_NAME (ElfW2(32, Ext##Word), p_flags) \
66	0	TYPE_NAME (ElfW2(32, Ext##Word), p_align) \
67	0	END (32, Ext##Phdr)
68	0	#define Phdr64(Ext) \
69	0	START (64, Phdr, Ext##Phdr) \
70	0	TYPE_NAME (ElfW2(64, Ext##Word), p_type) \
71	0	TYPE_NAME (ElfW2(64, Ext##Word), p_flags) \
72	0	TYPE_NAME (ElfW2(64, Ext##Off), p_offset) \
73	0	TYPE_NAME (ElfW2(64, Ext##Addr), p_vaddr) \
74	0	TYPE_NAME (ElfW2(64, Ext##Addr), p_paddr) \
75	0	TYPE_NAME (ElfW2(64, Ext##Xword), p_filesz) \
76	0	TYPE_NAME (ElfW2(64, Ext##Xword), p_memsz) \
77	0	TYPE_NAME (ElfW2(64, Ext##Xword), p_align) \
78	0	END (64, Ext##Phdr)
79
80
81		/* Section header. */
82	0	#define Shdr32(Ext) \
83	0	START (32, Shdr, Ext##Shdr) \
84	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_name) \
85	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_type) \
86	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_flags) \
87	0	TYPE_NAME (ElfW2(32, Ext##Addr), sh_addr) \
88	0	TYPE_NAME (ElfW2(32, Ext##Off), sh_offset) \
89	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_size) \
90	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_link) \
91	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_info) \
92	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_addralign) \
93	0	TYPE_NAME (ElfW2(32, Ext##Word), sh_entsize) \
94	0	END (32, Ext##Shdr)
95	0	#define Shdr64(Ext) \
96	0	START (64, Shdr, Ext##Shdr) \
97	0	TYPE_NAME (ElfW2(64, Ext##Word), sh_name) \
98	0	TYPE_NAME (ElfW2(64, Ext##Word), sh_type) \
99	0	TYPE_NAME (ElfW2(64, Ext##Xword), sh_flags) \
100	0	TYPE_NAME (ElfW2(64, Ext##Addr), sh_addr) \
101	0	TYPE_NAME (ElfW2(64, Ext##Off), sh_offset) \
102	0	TYPE_NAME (ElfW2(64, Ext##Xword), sh_size) \
103	0	TYPE_NAME (ElfW2(64, Ext##Word), sh_link) \
104	0	TYPE_NAME (ElfW2(64, Ext##Word), sh_info) \
105	0	TYPE_NAME (ElfW2(64, Ext##Xword), sh_addralign) \
106	0	TYPE_NAME (ElfW2(64, Ext##Xword), sh_entsize) \
107	0	END (64, Ext##Shdr)
108
109
110		/* Symbol table. */
111	0	#define Sym32(Ext) \
112	0	START (32, Sym, Ext##Sym) \
113	0	TYPE_NAME (ElfW2(32, Ext##Word), st_name) \
114	0	TYPE_NAME (ElfW2(32, Ext##Addr), st_value) \
115	0	TYPE_NAME (ElfW2(32, Ext##Word), st_size) \
116	0	TYPE_EXTRA (unsigned char st_info;) \
117	0	TYPE_XLATE (tdest->st_info = tsrc->st_info;) \
118	0	TYPE_EXTRA (unsigned char st_other;) \
119	0	TYPE_XLATE (tdest->st_other = tsrc->st_other;) \
120	0	TYPE_NAME (ElfW2(32, Ext##Half), st_shndx) \
121	0	END (32, Ext##Sym)
122	0	#define Sym64(Ext) \
123	0	START (64, Sym, Ext##Sym) \
124	0	TYPE_NAME (ElfW2(64, Ext##Word), st_name) \
125	0	TYPE_EXTRA (unsigned char st_info;) \
126	0	TYPE_XLATE (tdest->st_info = tsrc->st_info;) \
127	0	TYPE_EXTRA (unsigned char st_other;) \
128	0	TYPE_XLATE (tdest->st_other = tsrc->st_other;) \
129	0	TYPE_NAME (ElfW2(64, Ext##Half), st_shndx) \
130	0	TYPE_NAME (ElfW2(64, Ext##Addr), st_value) \
131	0	TYPE_NAME (ElfW2(64, Ext##Xword), st_size) \
132	0	END (64, Ext##Sym)
133
134
135		/* Relocation. */
136	0	#define Rel32(Ext) \
137	0	START (32, Rel, Ext##Rel) \
138	0	TYPE_NAME (ElfW2(32, Ext##Addr), r_offset) \
139	0	TYPE_NAME (ElfW2(32, Ext##Word), r_info) \
140	0	END (32, Ext##Rel)
141	0	#define Rel64(Ext) \
142	0	START (64, Rel, Ext##Rel) \
143	0	TYPE_NAME (ElfW2(64, Ext##Addr), r_offset) \
144	0	TYPE_NAME (ElfW2(64, Ext##Xword), r_info) \
145	0	END (64, Ext##Rel)
146
147	0	#define Rela32(Ext) \
148	0	START (32, Rela, Ext##Rela) \
149	0	TYPE_NAME (ElfW2(32, Ext##Addr), r_offset) \
150	0	TYPE_NAME (ElfW2(32, Ext##Word), r_info) \
151	0	TYPE_NAME (ElfW2(32, Ext##Sword), r_addend) \
152	0	END (32, Ext##Rela)
153	0	#define Rela64(Ext) \
154	0	START (64, Rela, Ext##Rela) \
155	0	TYPE_NAME (ElfW2(64, Ext##Addr), r_offset) \
156	0	TYPE_NAME (ElfW2(64, Ext##Xword), r_info) \
157	0	TYPE_NAME (ElfW2(64, Ext##Sxword), r_addend) \
158	0	END (64, Ext##Rela)
159
160
161		/* Note entry header. */
162	0	#define Note(Bits, Ext) \
163	0	START (Bits, Nhdr, Ext##Nhdr) \
164	0	TYPE_NAME (ElfW2(Bits, Ext##Word), n_namesz) \
165	0	TYPE_NAME (ElfW2(Bits, Ext##Word), n_descsz) \
166	0	TYPE_NAME (ElfW2(Bits, Ext##Word), n_type) \
167	0	END (Bits, Ext##Nhdr) Unexecuted instantiation: gelf_xlate.c:Elf32_cvt_Nhdr Unexecuted instantiation: gelf_xlate.c:Elf64_cvt_Nhdr
168
169		#define Note32(Ext) \
170		Note (32, Ext)
171		#define Note64(Ext) \
172		Note (64, Ext)
173
174
175		/* Dynamic section data. */
176	0	#define Dyn32(Ext) \
177	0	START (32, Dyn, Ext##Dyn) \
178	0	TYPE_NAME (ElfW2(32, Ext##Sword), d_tag) \
179	0	TYPE_EXTRA (union {) \
180	0	TYPE_EXTRA (ElfW2(32, Ext##Word) d_val;) \
181	0	TYPE_EXTRA (ElfW2(32, Ext##Addr) d_ptr;) \
182	0	TYPE_XLATE (Elf32_cvt_Addr1 (&tdest->d_un.d_val, &tsrc->d_un.d_val);) \
183	0	TYPE_EXTRA (ElfW2(32, Ext##Off) d_off;) \
184	0	TYPE_EXTRA (} d_un;) \
185	0	END (32, Ext##Dyn)
186	0	#define Dyn64(Ext) \
187	0	START (64, Dyn, Ext##Dyn) \
188	0	TYPE_NAME (ElfW2(64, Ext##Xword), d_tag) \
189	0	TYPE_EXTRA (union {) \
190	0	TYPE_EXTRA (ElfW2(64, Ext##Xword) d_val;) \
191	0	TYPE_EXTRA (ElfW2(64, Ext##Addr) d_ptr;) \
192	0	TYPE_XLATE (Elf64_cvt_Addr1 (&tdest->d_un.d_val, &tsrc->d_un.d_val);) \
193	0	TYPE_EXTRA (} d_un;) \
194	0	END (64, Ext##Dyn)
195
196
197		#ifndef GENERATE_CONVERSION
198		/* Version definitions. */
199		# define Verdef(Bits, Ext) \
200		START (Bits, Verdef, Ext##Verdef) \
201		TYPE_NAME (ElfW2(Bits, Ext##Half), vd_version) \
202		TYPE_NAME (ElfW2(Bits, Ext##Half), vd_flags) \
203		TYPE_NAME (ElfW2(Bits, Ext##Half), vd_ndx) \
204		TYPE_NAME (ElfW2(Bits, Ext##Half), vd_cnt) \
205		TYPE_NAME (ElfW2(Bits, Ext##Word), vd_hash) \
206		TYPE_NAME (ElfW2(Bits, Ext##Word), vd_aux) \
207		TYPE_NAME (ElfW2(Bits, Ext##Word), vd_next) \
208		END (Bits, Ext##Verdef)
209
210		# define Verdef32(Ext) \
211		Verdef (32, Ext)
212		# define Verdef64(Ext) \
213		Verdef (64, Ext)
214
215		# define Verdaux(Bits, Ext) \
216		START (Bits, Verdaux, Ext##Verdaux) \
217		TYPE_NAME (ElfW2(Bits, Ext##Word), vda_name) \
218		TYPE_NAME (ElfW2(Bits, Ext##Word), vda_next) \
219		END (Bits, Ext##Verdaux)
220
221		# define Verdaux32(Ext) \
222		Verdaux (32, Ext)
223		# define Verdaux64(Ext) \
224		Verdaux (64, Ext)
225
226		/* Required versions. */
227		# define Verneed(Bits, Ext) \
228		START (Bits, Verneed, Ext##Verneed) \
229		TYPE_NAME (ElfW2(Bits, Ext##Half), vn_version) \
230		TYPE_NAME (ElfW2(Bits, Ext##Half), vn_cnt) \
231		TYPE_NAME (ElfW2(Bits, Ext##Word), vn_file) \
232		TYPE_NAME (ElfW2(Bits, Ext##Word), vn_aux) \
233		TYPE_NAME (ElfW2(Bits, Ext##Word), vn_next) \
234		END (Bits, Ext##Verneed)
235
236		# define Verneed32(Ext) \
237		Verneed (32, Ext)
238		# define Verneed64(Ext) \
239		Verneed (64, Ext)
240
241		# define Vernaux(Bits, Ext) \
242		START (Bits, Vernaux, Ext##Vernaux) \
243		TYPE_NAME (ElfW2(Bits, Ext##Word), vna_hash) \
244		TYPE_NAME (ElfW2(Bits, Ext##Half), vna_flags) \
245		TYPE_NAME (ElfW2(Bits, Ext##Half), vna_other) \
246		TYPE_NAME (ElfW2(Bits, Ext##Word), vna_name) \
247		TYPE_NAME (ElfW2(Bits, Ext##Word), vna_next) \
248		END (Bits, Ext##Vernaux)
249
250		# define Vernaux32(Ext) \
251		Vernaux (32, Ext)
252		# define Vernaux64(Ext) \
253		Vernaux (64, Ext)
254		#endif
255
256		/* Symbol information. */
257	0	#define Syminfo(Bits, Ext) \
258	0	START (Bits, Syminfo, Ext##Syminfo) \
259	0	TYPE_NAME (ElfW2(Bits, Ext##Half), si_boundto) \
260	0	TYPE_NAME (ElfW2(Bits, Ext##Half), si_flags) \
261	0	END (Bits, Ext##Syminfo) Unexecuted instantiation: gelf_xlate.c:Elf32_cvt_Syminfo Unexecuted instantiation: gelf_xlate.c:Elf64_cvt_Syminfo
262
263		#define Syminfo32(Ext) \
264		Syminfo (32, Ext)
265		#define Syminfo64(Ext) \
266		Syminfo (64, Ext)
267
268		/* Move information. */
269	0	#define Move(Bits, Ext) \
270	0	START (Bits, Move, Ext##Move) \
271	0	TYPE_NAME (ElfW2(Bits, Ext##Xword), m_value) \
272	0	TYPE_NAME (ElfW2(Bits, Ext##Xword), m_info) \
273	0	TYPE_NAME (ElfW2(Bits, Ext##Xword), m_poffset) \
274	0	TYPE_NAME (ElfW2(Bits, Ext##Half), m_repeat) \
275	0	TYPE_NAME (ElfW2(Bits, Ext##Half), m_stride) \
276	0	END (Bits, Ext##Move) Unexecuted instantiation: gelf_xlate.c:Elf32_cvt_Move Unexecuted instantiation: gelf_xlate.c:Elf64_cvt_Move
277
278		#define Move32(Ext) \
279		Move (32, Ext)
280		#define Move64(Ext) \
281		Move (64, Ext)
282
283	0	#define Lib(Bits, Ext) \
284	0	START (Bits, Lib, Ext##Lib) \
285	0	TYPE_NAME (ElfW2(Bits, Ext##Word), l_name) \
286	0	TYPE_NAME (ElfW2(Bits, Ext##Word), l_time_stamp) \
287	0	TYPE_NAME (ElfW2(Bits, Ext##Word), l_checksum) \
288	0	TYPE_NAME (ElfW2(Bits, Ext##Word), l_version) \
289	0	TYPE_NAME (ElfW2(Bits, Ext##Word), l_flags) \
290	0	END (Bits, Ext##Lib) Unexecuted instantiation: gelf_xlate.c:Elf32_cvt_Lib Unexecuted instantiation: gelf_xlate.c:Elf64_cvt_Lib
291
292		#define Lib32(Ext) \
293		Lib (32, Ext)
294		#define Lib64(Ext) \
295		Lib (64, Ext)
296
297	0	#define auxv_t32(Ext) \
298	0	START (32, auxv_t, Ext##auxv_t) \
299	0	TYPE_NAME (ElfW2(32, Ext##Word), a_type) \
300	0	TYPE_EXTRA (union {) \
301	0	TYPE_EXTRA (ElfW2(32, Ext##Word) a_val;) \
302	0	TYPE_XLATE (Elf32_cvt_Addr1 (&tdest->a_un.a_val, &tsrc->a_un.a_val);) \
303	0	TYPE_EXTRA (} a_un;) \
304	0	END (32, Ext##auxv_t)
305	0	#define auxv_t64(Ext) \
306	0	START (64, auxv_t, Ext##auxv_t) \
307	0	TYPE_NAME (ElfW2(64, Ext##Xword), a_type) \
308	0	TYPE_EXTRA (union {) \
309	0	TYPE_EXTRA (ElfW2(64, Ext##Xword) a_val;) \
310	0	TYPE_XLATE (Elf64_cvt_Addr1 (&tdest->a_un.a_val, &tsrc->a_un.a_val);) \
311	0	TYPE_EXTRA (} a_un;) \
312	0	END (64, Ext##auxv_t)
313
314		/* Note that there is actual compression data right after the Chdr.
315		So we also have a separate conversion function for the whole
316		section. */
317	0	#define Chdr32(Ext) \
318	0	START (32, Chdr, Ext##Chdr) \
319	0	TYPE_NAME (ElfW2(32, Ext##Word), ch_type) \
320	0	TYPE_NAME (ElfW2(32, Ext##Word), ch_size) \
321	0	TYPE_NAME (ElfW2(32, Ext##Word), ch_addralign) \
322	0	END (32, Ext##Chdr)
323
324	0	#define Chdr64(Ext) \
325	0	START (64, Chdr, Ext##Chdr) \
326	0	TYPE_NAME (ElfW2(64, Ext##Word), ch_type) \
327	0	TYPE_NAME (ElfW2(64, Ext##Word), ch_reserved) \
328	0	TYPE_NAME (ElfW2(64, Ext##Xword), ch_size) \
329	0	TYPE_NAME (ElfW2(64, Ext##Xword), ch_addralign) \
330	0	END (64, Ext##Chdr)