1 #!/usr/bin/python3
2 # Verify scripts/glibcelf.py contents against elf/elf.h.
3 # Copyright (C) 2022-2023 Free Software Foundation, Inc.
4 # This file is part of the GNU C Library.
5 #
6 # The GNU C Library is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU Lesser General Public
8 # License as published by the Free Software Foundation; either
9 # version 2.1 of the License, or (at your option) any later version.
10 #
11 # The GNU C Library is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 # Lesser General Public License for more details.
15 #
16 # You should have received a copy of the GNU Lesser General Public
17 # License along with the GNU C Library; if not, see
18 # <https://www.gnu.org/licenses/>.
19
20 import argparse
21 import sys
22
23 import glibcelf
24 import glibcextract
25
26 errors_encountered = 0
27
28 def error(message):
29 global errors_encountered
30 sys.stdout.write('error: {}\n'.format(message))
31 errors_encountered += 1
32
33 # The enum constants in glibcelf are expected to have exactly these
34 # prefixes.
35 expected_constant_prefixes = tuple(
36 'ELFCLASS ELFDATA EM_ ET_ DT_ PF_ PT_ SHF_ SHN_ SHT_ STB_ STT_'.split())
37
38 def find_constant_prefix(name):
39 """Returns a matching prefix from expected_constant_prefixes or None."""
40 for prefix in expected_constant_prefixes:
41 if name.startswith(prefix):
42 return prefix
43 return None
44
45 def find_enum_types():
46 """A generator for OpenIntEnum and IntFlag classes in glibcelf."""
47 classes = set((glibcelf._TypedConstant, glibcelf._IntConstant,
48 glibcelf._FlagConstant))
49 for obj in vars(glibcelf).values():
50 if isinstance(obj, type) and obj not in classes \
51 and obj.__bases__[0] in classes:
52 yield obj
53
54 def check_basic():
55 """Check basic functionality of the constant classes."""
56
57 if glibcelf.Pt.PT_NULL is not glibcelf.Pt(0):
58 error('Pt(0) not interned')
59 if glibcelf.Pt(17609) is glibcelf.Pt(17609):
60 error('Pt(17609) unexpectedly interned')
61 if glibcelf.Pt(17609) == glibcelf.Pt(17609):
62 pass
63 else:
64 error('Pt(17609) equality')
65 if glibcelf.Pt(17610) == glibcelf.Pt(17609):
66 error('Pt(17610) equality')
67
68 if str(glibcelf.Pt.PT_NULL) != 'PT_NULL':
69 error('str(PT_NULL)')
70 if str(glibcelf.Pt(17609)) != '17609':
71 error('str(Pt(17609))')
72
73 if repr(glibcelf.Pt.PT_NULL) != 'PT_NULL':
74 error('repr(PT_NULL)')
75 if repr(glibcelf.Pt(17609)) != 'Pt(17609)':
76 error('repr(Pt(17609))')
77
78 if glibcelf.Pt('PT_AARCH64_MEMTAG_MTE') \
79 is not glibcelf.Pt.PT_AARCH64_MEMTAG_MTE:
80 error('PT_AARCH64_MEMTAG_MTE identity')
81 if glibcelf.Pt(0x70000002) is glibcelf.Pt.PT_AARCH64_MEMTAG_MTE:
82 error('Pt(0x70000002) identity')
83 if glibcelf.PtAARCH64(0x70000002) is not glibcelf.Pt.PT_AARCH64_MEMTAG_MTE:
84 error('PtAARCH64(0x70000002) identity')
85 if glibcelf.Pt.PT_AARCH64_MEMTAG_MTE.short_name != 'AARCH64_MEMTAG_MTE':
86 error('PT_AARCH64_MEMTAG_MTE short name')
87
88 # Special cases for int-like Shn.
89 if glibcelf.Shn(32) == glibcelf.Shn.SHN_XINDEX:
90 error('Shn(32)')
91 if glibcelf.Shn(32) + 0 != 32:
92 error('Shn(32) + 0')
93 if 32 in glibcelf.Shn:
94 error('32 in Shn')
95 if 0 not in glibcelf.Shn:
96 error('0 not in Shn')
97
98 def check_duplicates():
99 """Verifies that enum types do not have duplicate values.
100
101 Different types must have different member names, too.
102
103 """
104 global_seen = {}
105 for typ in find_enum_types():
106 seen = {}
107 for (name, e) in typ.by_name.items():
108 if e.value in seen:
109 other = seen[e.value]
110 # Value conflicts only count if they are between
111 # the same base type.
112 if e.__class__ is typ and other.__class__ is typ:
113 error('{} has {}={} and {}={}'.format(
114 typ, other, e.value, name, e.value))
115 else:
116 seen[e.value] = name
117 if name in global_seen:
118 error('{} used in {} and {}'.format(
119 name, global_seen[name], typ))
120 else:
121 global_seen[name] = typ
122
123 def check_constant_prefixes():
124 """Check that the constant prefixes match expected_constant_prefixes."""
125 seen = set()
126 for typ in find_enum_types():
127 typ_prefix = None
128 for val in typ.by_name.values():
129 prefix = find_constant_prefix(val.name)
130 if prefix is None:
131 error('constant {!r} for {} has unknown prefix'.format(
132 val, typ))
133 break
134 elif typ_prefix is None:
135 typ_prefix = prefix
136 seen.add(typ_prefix)
137 elif prefix != typ_prefix:
138 error('prefix {!r} for constant {!r}, expected {!r}'.format(
139 prefix, val, typ_prefix))
140 if typ_prefix is None:
141 error('empty enum type {}'.format(typ))
142
143 for prefix in sorted(set(expected_constant_prefixes) - seen):
144 error('missing constant prefix {!r}'.format(prefix))
145 # Reverse difference is already covered inside the loop.
146
147 def find_elf_h_constants(cc):
148 """Returns a dictionary of relevant constants from <elf.h>."""
149 return glibcextract.compute_macro_consts(
150 source_text='#include <elf.h>',
151 cc=cc,
152 macro_re='|'.join(
153 prefix + '.*' for prefix in expected_constant_prefixes))
154
155 # The first part of the pair is a name of an <elf.h> constant that is
156 # dropped from glibcelf. The second part is the constant as it is
157 # used in <elf.h>.
158 glibcelf_skipped_aliases = (
159 ('EM_ARC_A5', 'EM_ARC_COMPACT'),
160 )
161
162 # Constants that provide little value and are not included in
163 # glibcelf: *LO*/*HI* range constants, *NUM constants counting the
164 # number of constants. Also includes the alias names from
165 # glibcelf_skipped_aliases.
166 glibcelf_skipped_constants = frozenset(
167 [e[0] for e in glibcelf_skipped_aliases]) | frozenset("""
168 DT_AARCH64_NUM
169 DT_ADDRNUM
170 DT_ADDRRNGHI
171 DT_ADDRRNGLO
172 DT_ALPHA_NUM
173 DT_ENCODING
174 DT_EXTRANUM
175 DT_HIOS
176 DT_HIPROC
177 DT_IA_64_NUM
178 DT_LOOS
179 DT_LOPROC
180 DT_MIPS_NUM
181 DT_NUM
182 DT_PPC64_NUM
183 DT_PPC_NUM
184 DT_PROCNUM
185 DT_SPARC_NUM
186 DT_VALNUM
187 DT_VALRNGHI
188 DT_VALRNGLO
189 DT_VERSIONTAGNUM
190 ELFCLASSNUM
191 ELFDATANUM
192 EM_NUM
193 ET_HIOS
194 ET_HIPROC
195 ET_LOOS
196 ET_LOPROC
197 ET_NUM
198 PF_MASKOS
199 PF_MASKPROC
200 PT_HIOS
201 PT_HIPROC
202 PT_HISUNW
203 PT_LOOS
204 PT_LOPROC
205 PT_LOSUNW
206 PT_NUM
207 SHF_MASKOS
208 SHF_MASKPROC
209 SHN_HIOS
210 SHN_HIPROC
211 SHN_HIRESERVE
212 SHN_LOOS
213 SHN_LOPROC
214 SHN_LORESERVE
215 SHT_HIOS
216 SHT_HIPROC
217 SHT_HIPROC
218 SHT_HISUNW
219 SHT_HIUSER
220 SHT_LOOS
221 SHT_LOPROC
222 SHT_LOSUNW
223 SHT_LOUSER
224 SHT_NUM
225 STB_HIOS
226 STB_HIPROC
227 STB_LOOS
228 STB_LOPROC
229 STB_NUM
230 STT_HIOS
231 STT_HIPROC
232 STT_LOOS
233 STT_LOPROC
234 STT_NUM
235 """.strip().split())
236
237 def check_constant_values(cc):
238 """Checks the values of <elf.h> constants against glibcelf."""
239
240 glibcelf_constants = {
241 e.name: e for typ in find_enum_types() for e in typ.by_name.values()}
242 elf_h_constants = find_elf_h_constants(cc=cc)
243
244 missing_in_glibcelf = (set(elf_h_constants) - set(glibcelf_constants)
245 - glibcelf_skipped_constants)
246 for name in sorted(missing_in_glibcelf):
247 error('constant {} is missing from glibcelf'.format(name))
248
249 unexpected_in_glibcelf = \
250 set(glibcelf_constants) & glibcelf_skipped_constants
251 for name in sorted(unexpected_in_glibcelf):
252 error('constant {} is supposed to be filtered from glibcelf'.format(
253 name))
254
255 missing_in_elf_h = set(glibcelf_constants) - set(elf_h_constants)
256 for name in sorted(missing_in_elf_h):
257 error('constant {} is missing from <elf.h>'.format(name))
258
259 expected_in_elf_h = glibcelf_skipped_constants - set(elf_h_constants)
260 for name in expected_in_elf_h:
261 error('filtered constant {} is missing from <elf.h>'.format(name))
262
263 for alias_name, name_in_glibcelf in glibcelf_skipped_aliases:
264 if name_in_glibcelf not in glibcelf_constants:
265 error('alias value {} for {} not in glibcelf'.format(
266 name_in_glibcelf, alias_name))
267 elif (int(elf_h_constants[alias_name])
268 != glibcelf_constants[name_in_glibcelf].value):
269 error('<elf.h> has {}={}, glibcelf has {}={}'.format(
270 alias_name, elf_h_constants[alias_name],
271 name_in_glibcelf, glibcelf_constants[name_in_glibcelf]))
272
273 # Check for value mismatches:
274 for name in sorted(set(glibcelf_constants) & set(elf_h_constants)):
275 glibcelf_value = glibcelf_constants[name].value
276 elf_h_value = int(elf_h_constants[name])
277 # On 32-bit architectures <elf.h> has some constants that are
278 # parsed as signed, while they are unsigned in glibcelf. So
279 # far, this only affects some flag constants, so special-case
280 # them here.
281 if (glibcelf_value != elf_h_value
282 and not (isinstance(glibcelf_constants[name],
283 glibcelf._FlagConstant)
284 and glibcelf_value == 1 << 31
285 and elf_h_value == -(1 << 31))):
286 error('{}: glibcelf has {!r}, <elf.h> has {!r}'.format(
287 name, glibcelf_value, elf_h_value))
288
289 def check_hashes():
290 for name, expected_elf, expected_gnu in (
291 ('', 0, 0x1505),
292 ('PPPPPPPPPPPP', 0, 0x9f105c45),
293 ('GLIBC_2.0', 0xd696910, 0xf66c3dd5),
294 ('GLIBC_2.34', 0x69691b4, 0xc3f3f90c),
295 ('GLIBC_PRIVATE', 0x963cf85, 0x692a260)):
296 for convert in (lambda x: x, lambda x: x.encode('UTF-8')):
297 name = convert(name)
298 actual_elf = glibcelf.elf_hash(name)
299 if actual_elf != expected_elf:
300 error('elf_hash({!r}): {:x} != 0x{:x}'.format(
301 name, actual_elf, expected_elf))
302 actual_gnu = glibcelf.gnu_hash(name)
303 if actual_gnu != expected_gnu:
304 error('gnu_hash({!r}): {:x} != 0x{:x}'.format(
305 name, actual_gnu, expected_gnu))
306
307 def main():
308 """The main entry point."""
309 parser = argparse.ArgumentParser(
310 description="Check glibcelf.py and elf.h against each other.")
311 parser.add_argument('--cc', metavar='CC',
312 help='C compiler (including options) to use')
313 args = parser.parse_args()
314
315 check_basic()
316 check_duplicates()
317 check_constant_prefixes()
318 check_constant_values(cc=args.cc)
319 check_hashes()
320
321 if errors_encountered > 0:
322 print("note: errors encountered:", errors_encountered)
323 sys.exit(1)
324
325 if __name__ == '__main__':
326 main()