projects/guix·blob javascript-team · refs

1046 lines · 42.1 KiB

1;;; Guile ELF reader and writer
2
3;; Copyright (C) 2011, 2012, 2013, 2014, 2015 Free Software Foundation, Inc.
4
5;;;; This library is free software; you can redistribute it and/or
6;;;; modify it under the terms of the GNU Lesser General Public
7;;;; License as published by the Free Software Foundation; either
8;;;; version 3 of the License, or (at your option) any later version.
9;;;;
10;;;; This library is distributed in the hope that it will be useful,
11;;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
12;;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13;;;; Lesser General Public License for more details.
14;;;;
15;;;; You should have received a copy of the GNU Lesser General Public
16;;;; License along with this library; if not, write to the Free Software
17;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
19;;; Commentary:
20;;;
21;;; This file was taken from the Guile 2.1 branch, where it is known as
22;;; (system vm elf), and renamed to (guix elf). It will be unneeded when Guix
23;;; switches to Guile 2.1/2.2.
24;;;
25;;; A module to read and write Executable and Linking Format (ELF)
26;;; files.
27;;;
28;;; This module exports a number of record types that represent the
29;;; various parts that make up ELF files. Fundamentally this is the
30;;; main header, the segment headers (program headers), and the section
31;;; headers. It also exports bindings for symbolic constants and
32;;; utilities to parse and write special kinds of ELF sections.
33;;;
34;;; See elf(5) for more information on ELF.
35;;;
36;;; Code:
37
38(define-module (guix elf)
39 #:use-module (rnrs bytevectors)
40 #:use-module (system foreign)
41 #:use-module (system base target)
42 #:use-module (srfi srfi-9)
43 #:use-module (ice-9 receive)
44 #:use-module (ice-9 vlist)
45 #:export (has-elf-header?
46
47 (make-elf* . make-elf)
48 elf?
49 elf-bytes elf-word-size elf-byte-order
50 elf-abi elf-type elf-machine-type
51 elf-entry elf-phoff elf-shoff elf-flags elf-ehsize
52 elf-phentsize elf-phnum elf-shentsize elf-shnum elf-shstrndx
53
54 ELFOSABI_NONE ELFOSABI_HPUX ELFOSABI_NETBSD ELFOSABI_GNU
55 ELFOSABI_SOLARIS ELFOSABI_AIX ELFOSABI_IRIX ELFOSABI_FREEBSD
56 ELFOSABI_TRU64 ELFOSABI_MODESTO ELFOSABI_OPENBSD
57 ELFOSABI_ARM_AEABI ELFOSABI_ARM ELFOSABI_STANDALONE
58
59 ET_NONE ET_REL ET_EXEC ET_DYN ET_CORE
60
61 EM_NONE EM_SPARC EM_386 EM_MIPS EM_PPC EM_PPC64 EM_ARM EM_SH
62 EM_SPARCV9 EM_IA_64 EM_X86_64
63
64 elf-header-len elf-header-shoff-offset
65 write-elf-header
66
67 (make-elf-segment* . make-elf-segment)
68 elf-segment?
69 elf-segment-index
70 elf-segment-type elf-segment-offset elf-segment-vaddr
71 elf-segment-paddr elf-segment-filesz elf-segment-memsz
72 elf-segment-flags elf-segment-align
73
74 elf-program-header-len write-elf-program-header
75
76 PT_NULL PT_LOAD PT_DYNAMIC PT_INTERP PT_NOTE PT_SHLIB
77 PT_PHDR PT_TLS PT_NUM PT_LOOS PT_GNU_EH_FRAME PT_GNU_STACK
78 PT_GNU_RELRO
79
80 PF_R PF_W PF_X
81
82 (make-elf-section* . make-elf-section)
83 elf-section?
84 elf-section-index
85 elf-section-name elf-section-type elf-section-flags
86 elf-section-addr elf-section-offset elf-section-size
87 elf-section-link elf-section-info elf-section-addralign
88 elf-section-entsize
89
90 elf-section-header-len elf-section-header-addr-offset
91 elf-section-header-offset-offset
92 write-elf-section-header
93
94 (make-elf-symbol* . make-elf-symbol)
95 elf-symbol?
96 elf-symbol-name elf-symbol-value elf-symbol-size
97 elf-symbol-info elf-symbol-other elf-symbol-shndx
98 elf-symbol-binding elf-symbol-type elf-symbol-visibility
99
100 elf-symbol-len elf-symbol-value-offset write-elf-symbol
101
102 SHN_UNDEF
103
104 SHT_NULL SHT_PROGBITS SHT_SYMTAB SHT_STRTAB SHT_RELA
105 SHT_HASH SHT_DYNAMIC SHT_NOTE SHT_NOBITS SHT_REL SHT_SHLIB
106 SHT_DYNSYM SHT_INIT_ARRAY SHT_FINI_ARRAY SHT_PREINIT_ARRAY
107 SHT_GROUP SHT_SYMTAB_SHNDX SHT_NUM SHT_LOOS SHT_HIOS
108 SHT_LOPROC SHT_HIPROC SHT_LOUSER SHT_HIUSER
109
110 SHF_WRITE SHF_ALLOC SHF_EXECINSTR SHF_MERGE SHF_STRINGS
111 SHF_INFO_LINK SHF_LINK_ORDER SHF_OS_NONCONFORMING SHF_GROUP
112 SHF_TLS
113
114 DT_NULL DT_NEEDED DT_PLTRELSZ DT_PLTGOT DT_HASH DT_STRTAB
115 DT_SYMTAB DT_RELA DT_RELASZ DT_RELAENT DT_STRSZ DT_SYMENT
116 DT_INIT DT_FINI DT_SONAME DT_RPATH DT_SYMBOLIC DT_REL
117 DT_RELSZ DT_RELENT DT_PLTREL DT_DEBUG DT_TEXTREL DT_JMPREL
118 DT_BIND_NOW DT_INIT_ARRAY DT_FINI_ARRAY DT_INIT_ARRAYSZ
119 DT_FINI_ARRAYSZ DT_RUNPATH DT_FLAGS DT_ENCODING
120 DT_PREINIT_ARRAY DT_PREINIT_ARRAYSZ DT_NUM DT_LOGUILE
121 DT_GUILE_GC_ROOT DT_GUILE_GC_ROOT_SZ DT_GUILE_ENTRY
122 DT_GUILE_VM_VERSION DT_GUILE_FRAME_MAPS DT_HIGUILE
123 DT_LOOS DT_HIOS DT_LOPROC DT_HIPROC
124
125 string-table-ref
126
127 STB_LOCAL STB_GLOBAL STB_WEAK STB_NUM STB_LOOS STB_GNU
128 STB_HIOS STB_LOPROC STB_HIPROC
129
130 STT_NOTYPE STT_OBJECT STT_FUNC STT_SECTION STT_FILE
131 STT_COMMON STT_TLS STT_NUM STT_LOOS STT_GNU STT_HIOS
132 STT_LOPROC STT_HIPROC
133
134 STV_DEFAULT STV_INTERNAL STV_HIDDEN STV_PROTECTED
135
136 NT_GNU_ABI_TAG NT_GNU_HWCAP NT_GNU_BUILD_ID NT_GNU_GOLD_VERSION
137
138 parse-elf
139 elf-segment elf-segments
140 elf-section elf-sections elf-section-by-name elf-sections-by-name
141 elf-symbol-table-len elf-symbol-table-ref
142
143 parse-elf-note
144 elf-note-name elf-note-desc elf-note-type))
145
146;; #define EI_NIDENT 16
147
148;; typedef struct {
149;; unsigned char e_ident[EI_NIDENT];
150;; uint16_t e_type;
151;; uint16_t e_machine;
152;; uint32_t e_version;
153;; ElfN_Addr e_entry;
154;; ElfN_Off e_phoff;
155;; ElfN_Off e_shoff;
156;; uint32_t e_flags;
157;; uint16_t e_ehsize;
158;; uint16_t e_phentsize;
159;; uint16_t e_phnum;
160;; uint16_t e_shentsize;
161;; uint16_t e_shnum;
162;; uint16_t e_shstrndx;
163;; } ElfN_Ehdr;
164
165(define elf32-header-len 52)
166(define elf64-header-len 64)
167(define (elf-header-len word-size)
168 (case word-size
169 ((4) elf32-header-len)
170 ((8) elf64-header-len)
171 (else (error "invalid word size" word-size))))
172(define (elf-header-shoff-offset word-size)
173 (case word-size
174 ((4) 32)
175 ((8) 40)
176 (else (error "bad word size" word-size))))
177
178(define ELFCLASS32 1) ; 32-bit objects
179(define ELFCLASS64 2) ; 64-bit objects
180
181(define ELFDATA2LSB 1) ; 2's complement, little endian
182(define ELFDATA2MSB 2) ; 2's complement, big endian
183
184(define EV_CURRENT 1) ; Current version
185
186(define ELFOSABI_NONE 0) ; UNIX System V ABI */
187(define ELFOSABI_HPUX 1) ; HP-UX
188(define ELFOSABI_NETBSD 2) ; NetBSD.
189(define ELFOSABI_GNU 3) ; Object uses GNU ELF extensions.
190(define ELFOSABI_SOLARIS 6) ; Sun Solaris.
191(define ELFOSABI_AIX 7) ; IBM AIX.
192(define ELFOSABI_IRIX 8) ; SGI Irix.
193(define ELFOSABI_FREEBSD 9) ; FreeBSD.
194(define ELFOSABI_TRU64 10) ; Compaq TRU64 UNIX.
195(define ELFOSABI_MODESTO 11) ; Novell Modesto.
196(define ELFOSABI_OPENBSD 12) ; OpenBSD.
197(define ELFOSABI_ARM_AEABI 64) ; ARM EABI
198(define ELFOSABI_ARM 97) ; ARM
199(define ELFOSABI_STANDALONE 255) ; Standalone (embedded) application
200
201(define ET_NONE 0) ; No file type
202(define ET_REL 1) ; Relocatable file
203(define ET_EXEC 2) ; Executable file
204(define ET_DYN 3) ; Shared object file
205(define ET_CORE 4) ; Core file
206
207;;
208;; Machine types
209;;
210;; Just a sampling of these values. We could include more, but the
211;; important thing is to recognize architectures for which we have a
212;; native compiler. Recognizing more common machine types is icing on
213;; the cake.
214;;
215(define EM_NONE 0) ; No machine
216(define EM_SPARC 2) ; SUN SPARC
217(define EM_386 3) ; Intel 80386
218(define EM_MIPS 8) ; MIPS R3000 big-endian
219(define EM_PPC 20) ; PowerPC
220(define EM_PPC64 21) ; PowerPC 64-bit
221(define EM_ARM 40) ; ARM
222(define EM_SH 42) ; Hitachi SH
223(define EM_SPARCV9 43) ; SPARC v9 64-bit
224(define EM_IA_64 50) ; Intel Merced
225(define EM_X86_64 62) ; AMD x86-64 architecture
226
227(define cpu-mapping (make-hash-table))
228(for-each (lambda (pair)
229 (hashq-set! cpu-mapping (car pair) (cdr pair)))
230 `((none . ,EM_NONE)
231 (sparc . ,EM_SPARC) ; FIXME: map 64-bit to SPARCV9 ?
232 (i386 . ,EM_386)
233 (mips . ,EM_MIPS)
234 (ppc . ,EM_PPC)
235 (ppc64 . ,EM_PPC64)
236 (arm . ,EM_ARM) ; FIXME: there are more arm cpu variants
237 (sh . ,EM_SH) ; FIXME: there are more sh cpu variants
238 (ia64 . ,EM_IA_64)
239 (x86_64 . ,EM_X86_64)))
240
241(define SHN_UNDEF 0)
242
243(define host-machine-type
244 (hashq-ref cpu-mapping
245 (string->symbol (car (string-split %host-type #\-)))
246 EM_NONE))
247
248(define host-word-size
249 (sizeof '*))
250
251(define host-byte-order
252 (native-endianness))
253
254(define (has-elf-header? bv)
255 (and
256 ;; e_ident
257 (>= (bytevector-length bv) 16)
258 (= (bytevector-u8-ref bv 0) #x7f)
259 (= (bytevector-u8-ref bv 1) (char->integer #\E))
260 (= (bytevector-u8-ref bv 2) (char->integer #\L))
261 (= (bytevector-u8-ref bv 3) (char->integer #\F))
262 (cond
263 ((= (bytevector-u8-ref bv 4) ELFCLASS32)
264 (>= (bytevector-length bv) elf32-header-len))
265 ((= (bytevector-u8-ref bv 4) ELFCLASS64)
266 (>= (bytevector-length bv) elf64-header-len))
267 (else #f))
268 (or (= (bytevector-u8-ref bv 5) ELFDATA2LSB)
269 (= (bytevector-u8-ref bv 5) ELFDATA2MSB))
270 (= (bytevector-u8-ref bv 6) EV_CURRENT)
271 ;; Look at ABI later.
272 (= (bytevector-u8-ref bv 8) 0) ; ABI version
273 ;; The rest of the e_ident is padding.
274
275 ;; e_version
276 (let ((byte-order (if (= (bytevector-u8-ref bv 5) ELFDATA2LSB)
277 (endianness little)
278 (endianness big))))
279 (= (bytevector-u32-ref bv 20 byte-order) EV_CURRENT))))
280
281(define-record-type <elf>
282 (make-elf bytes word-size byte-order abi type machine-type
283 entry phoff shoff flags ehsize
284 phentsize phnum shentsize shnum shstrndx)
285 elf?
286 (bytes elf-bytes)
287 (word-size elf-word-size)
288 (byte-order elf-byte-order)
289 (abi elf-abi)
290 (type elf-type)
291 (machine-type elf-machine-type)
292 (entry elf-entry)
293 (phoff elf-phoff)
294 (shoff elf-shoff)
295 (flags elf-flags)
296 (ehsize elf-ehsize)
297 (phentsize elf-phentsize)
298 (phnum elf-phnum)
299 (shentsize elf-shentsize)
300 (shnum elf-shnum)
301 (shstrndx elf-shstrndx))
302
303(define* (make-elf* #:key (bytes #f)
304 (byte-order (target-endianness))
305 (word-size (target-word-size))
306 (abi ELFOSABI_STANDALONE)
307 (type ET_DYN)
308 (machine-type EM_NONE)
309 (entry 0)
310 (phoff (elf-header-len word-size))
311 (shoff -1)
312 (flags 0)
313 (ehsize (elf-header-len word-size))
314 (phentsize (elf-program-header-len word-size))
315 (phnum 0)
316 (shentsize (elf-section-header-len word-size))
317 (shnum 0)
318 (shstrndx SHN_UNDEF))
319 (make-elf bytes word-size byte-order abi type machine-type
320 entry phoff shoff flags ehsize
321 phentsize phnum shentsize shnum shstrndx))
322
323(define (parse-elf32 bv byte-order)
324 (make-elf bv 4 byte-order
325 (bytevector-u8-ref bv 7)
326 (bytevector-u16-ref bv 16 byte-order)
327 (bytevector-u16-ref bv 18 byte-order)
328 (bytevector-u32-ref bv 24 byte-order)
329 (bytevector-u32-ref bv 28 byte-order)
330 (bytevector-u32-ref bv 32 byte-order)
331 (bytevector-u32-ref bv 36 byte-order)
332 (bytevector-u16-ref bv 40 byte-order)
333 (bytevector-u16-ref bv 42 byte-order)
334 (bytevector-u16-ref bv 44 byte-order)
335 (bytevector-u16-ref bv 46 byte-order)
336 (bytevector-u16-ref bv 48 byte-order)
337 (bytevector-u16-ref bv 50 byte-order)))
338
339(define (write-elf-ident bv class data abi)
340 (bytevector-u8-set! bv 0 #x7f)
341 (bytevector-u8-set! bv 1 (char->integer #\E))
342 (bytevector-u8-set! bv 2 (char->integer #\L))
343 (bytevector-u8-set! bv 3 (char->integer #\F))
344 (bytevector-u8-set! bv 4 class)
345 (bytevector-u8-set! bv 5 data)
346 (bytevector-u8-set! bv 6 EV_CURRENT)
347 (bytevector-u8-set! bv 7 abi)
348 (bytevector-u8-set! bv 8 0) ; ABI version
349 (bytevector-u8-set! bv 9 0) ; Pad to 16 bytes.
350 (bytevector-u8-set! bv 10 0)
351 (bytevector-u8-set! bv 11 0)
352 (bytevector-u8-set! bv 12 0)
353 (bytevector-u8-set! bv 13 0)
354 (bytevector-u8-set! bv 14 0)
355 (bytevector-u8-set! bv 15 0))
356
357(define (write-elf32-header bv elf)
358 (let ((byte-order (elf-byte-order elf)))
359 (write-elf-ident bv ELFCLASS32
360 (case byte-order
361 ((little) ELFDATA2LSB)
362 ((big) ELFDATA2MSB)
363 (else (error "unknown endianness" byte-order)))
364 (elf-abi elf))
365 (bytevector-u16-set! bv 16 (elf-type elf) byte-order)
366 (bytevector-u16-set! bv 18 (elf-machine-type elf) byte-order)
367 (bytevector-u32-set! bv 20 EV_CURRENT byte-order)
368 (bytevector-u32-set! bv 24 (elf-entry elf) byte-order)
369 (bytevector-u32-set! bv 28 (elf-phoff elf) byte-order)
370 (bytevector-u32-set! bv 32 (elf-shoff elf) byte-order)
371 (bytevector-u32-set! bv 36 (elf-flags elf) byte-order)
372 (bytevector-u16-set! bv 40 (elf-ehsize elf) byte-order)
373 (bytevector-u16-set! bv 42 (elf-phentsize elf) byte-order)
374 (bytevector-u16-set! bv 44 (elf-phnum elf) byte-order)
375 (bytevector-u16-set! bv 46 (elf-shentsize elf) byte-order)
376 (bytevector-u16-set! bv 48 (elf-shnum elf) byte-order)
377 (bytevector-u16-set! bv 50 (elf-shstrndx elf) byte-order)))
378
379(define (parse-elf64 bv byte-order)
380 (make-elf bv 8 byte-order
381 (bytevector-u8-ref bv 7)
382 (bytevector-u16-ref bv 16 byte-order)
383 (bytevector-u16-ref bv 18 byte-order)
384 (bytevector-u64-ref bv 24 byte-order)
385 (bytevector-u64-ref bv 32 byte-order)
386 (bytevector-u64-ref bv 40 byte-order)
387 (bytevector-u32-ref bv 48 byte-order)
388 (bytevector-u16-ref bv 52 byte-order)
389 (bytevector-u16-ref bv 54 byte-order)
390 (bytevector-u16-ref bv 56 byte-order)
391 (bytevector-u16-ref bv 58 byte-order)
392 (bytevector-u16-ref bv 60 byte-order)
393 (bytevector-u16-ref bv 62 byte-order)))
394
395(define (write-elf64-header bv elf)
396 (let ((byte-order (elf-byte-order elf)))
397 (write-elf-ident bv ELFCLASS64
398 (case byte-order
399 ((little) ELFDATA2LSB)
400 ((big) ELFDATA2MSB)
401 (else (error "unknown endianness" byte-order)))
402 (elf-abi elf))
403 (bytevector-u16-set! bv 16 (elf-type elf) byte-order)
404 (bytevector-u16-set! bv 18 (elf-machine-type elf) byte-order)
405 (bytevector-u32-set! bv 20 EV_CURRENT byte-order)
406 (bytevector-u64-set! bv 24 (elf-entry elf) byte-order)
407 (bytevector-u64-set! bv 32 (elf-phoff elf) byte-order)
408 (bytevector-u64-set! bv 40 (elf-shoff elf) byte-order)
409 (bytevector-u32-set! bv 48 (elf-flags elf) byte-order)
410 (bytevector-u16-set! bv 52 (elf-ehsize elf) byte-order)
411 (bytevector-u16-set! bv 54 (elf-phentsize elf) byte-order)
412 (bytevector-u16-set! bv 56 (elf-phnum elf) byte-order)
413 (bytevector-u16-set! bv 58 (elf-shentsize elf) byte-order)
414 (bytevector-u16-set! bv 60 (elf-shnum elf) byte-order)
415 (bytevector-u16-set! bv 62 (elf-shstrndx elf) byte-order)))
416
417(define (parse-elf bv)
418 (cond
419 ((has-elf-header? bv)
420 (let ((class (bytevector-u8-ref bv 4))
421 (byte-order (let ((data (bytevector-u8-ref bv 5)))
422 (cond
423 ((= data ELFDATA2LSB) (endianness little))
424 ((= data ELFDATA2MSB) (endianness big))
425 (else (error "unhandled byte order" data))))))
426 (cond
427 ((= class ELFCLASS32) (parse-elf32 bv byte-order))
428 ((= class ELFCLASS64) (parse-elf64 bv byte-order))
429 (else (error "unhandled class" class)))))
430 (else
431 (error "Invalid ELF" bv))))
432
433(define* (write-elf-header bv elf)
434 ((case (elf-word-size elf)
435 ((4) write-elf32-header)
436 ((8) write-elf64-header)
437 (else (error "unknown word size" (elf-word-size elf))))
438 bv elf))
439
440;;
441;; Segment types
442;;
443(define PT_NULL 0) ; Program header table entry unused
444(define PT_LOAD 1) ; Loadable program segment
445(define PT_DYNAMIC 2) ; Dynamic linking information
446(define PT_INTERP 3) ; Program interpreter
447(define PT_NOTE 4) ; Auxiliary information
448(define PT_SHLIB 5) ; Reserved
449(define PT_PHDR 6) ; Entry for header table itself
450(define PT_TLS 7) ; Thread-local storage segment
451(define PT_NUM 8) ; Number of defined types
452(define PT_LOOS #x60000000) ; Start of OS-specific
453(define PT_GNU_EH_FRAME #x6474e550) ; GCC .eh_frame_hdr segment
454(define PT_GNU_STACK #x6474e551) ; Indicates stack executability
455(define PT_GNU_RELRO #x6474e552) ; Read-only after relocation
456
457;;
458;; Segment flags
459;;
460(define PF_X (ash 1 0)) ; Segment is executable
461(define PF_W (ash 1 1)) ; Segment is writable
462(define PF_R (ash 1 2)) ; Segment is readable
463
464(define-record-type <elf-segment>
465 (make-elf-segment index type offset vaddr paddr filesz memsz flags align)
466 elf-segment?
467 (index elf-segment-index)
468 (type elf-segment-type)
469 (offset elf-segment-offset)
470 (vaddr elf-segment-vaddr)
471 (paddr elf-segment-paddr)
472 (filesz elf-segment-filesz)
473 (memsz elf-segment-memsz)
474 (flags elf-segment-flags)
475 (align elf-segment-align))
476
477(define* (make-elf-segment* #:key (index -1) (type PT_LOAD) (offset 0) (vaddr 0)
478 (paddr 0) (filesz 0) (memsz filesz)
479 (flags (logior PF_W PF_R))
480 (align 8))
481 (make-elf-segment index type offset vaddr paddr filesz memsz flags align))
482
483;; typedef struct {
484;; uint32_t p_type;
485;; Elf32_Off p_offset;
486;; Elf32_Addr p_vaddr;
487;; Elf32_Addr p_paddr;
488;; uint32_t p_filesz;
489;; uint32_t p_memsz;
490;; uint32_t p_flags;
491;; uint32_t p_align;
492;; } Elf32_Phdr;
493
494(define (parse-elf32-program-header index bv offset byte-order)
495 (if (<= (+ offset 32) (bytevector-length bv))
496 (make-elf-segment index
497 (bytevector-u32-ref bv offset byte-order)
498 (bytevector-u32-ref bv (+ offset 4) byte-order)
499 (bytevector-u32-ref bv (+ offset 8) byte-order)
500 (bytevector-u32-ref bv (+ offset 12) byte-order)
501 (bytevector-u32-ref bv (+ offset 16) byte-order)
502 (bytevector-u32-ref bv (+ offset 20) byte-order)
503 (bytevector-u32-ref bv (+ offset 24) byte-order)
504 (bytevector-u32-ref bv (+ offset 28) byte-order))
505 (error "corrupt ELF (offset out of range)" offset)))
506
507(define (write-elf32-program-header bv offset byte-order seg)
508 (bytevector-u32-set! bv offset (elf-segment-type seg) byte-order)
509 (bytevector-u32-set! bv (+ offset 4) (elf-segment-offset seg) byte-order)
510 (bytevector-u32-set! bv (+ offset 8) (elf-segment-vaddr seg) byte-order)
511 (bytevector-u32-set! bv (+ offset 12) (elf-segment-paddr seg) byte-order)
512 (bytevector-u32-set! bv (+ offset 16) (elf-segment-filesz seg) byte-order)
513 (bytevector-u32-set! bv (+ offset 20) (elf-segment-memsz seg) byte-order)
514 (bytevector-u32-set! bv (+ offset 24) (elf-segment-flags seg) byte-order)
515 (bytevector-u32-set! bv (+ offset 28) (elf-segment-align seg) byte-order))
516
517
518;; typedef struct {
519;; uint32_t p_type;
520;; uint32_t p_flags;
521;; Elf64_Off p_offset;
522;; Elf64_Addr p_vaddr;
523;; Elf64_Addr p_paddr;
524;; uint64_t p_filesz;
525;; uint64_t p_memsz;
526;; uint64_t p_align;
527;; } Elf64_Phdr;
528
529;; NB: position of `flags' is different!
530
531(define (parse-elf64-program-header index bv offset byte-order)
532 (if (<= (+ offset 56) (bytevector-length bv))
533 (make-elf-segment index
534 (bytevector-u32-ref bv offset byte-order)
535 (bytevector-u64-ref bv (+ offset 8) byte-order)
536 (bytevector-u64-ref bv (+ offset 16) byte-order)
537 (bytevector-u64-ref bv (+ offset 24) byte-order)
538 (bytevector-u64-ref bv (+ offset 32) byte-order)
539 (bytevector-u64-ref bv (+ offset 40) byte-order)
540 (bytevector-u32-ref bv (+ offset 4) byte-order)
541 (bytevector-u64-ref bv (+ offset 48) byte-order))
542 (error "corrupt ELF (offset out of range)" offset)))
543
544(define (write-elf64-program-header bv offset byte-order seg)
545 (bytevector-u32-set! bv offset (elf-segment-type seg) byte-order)
546 (bytevector-u64-set! bv (+ offset 8) (elf-segment-offset seg) byte-order)
547 (bytevector-u64-set! bv (+ offset 16) (elf-segment-vaddr seg) byte-order)
548 (bytevector-u64-set! bv (+ offset 24) (elf-segment-paddr seg) byte-order)
549 (bytevector-u64-set! bv (+ offset 32) (elf-segment-filesz seg) byte-order)
550 (bytevector-u64-set! bv (+ offset 40) (elf-segment-memsz seg) byte-order)
551 (bytevector-u32-set! bv (+ offset 4) (elf-segment-flags seg) byte-order)
552 (bytevector-u64-set! bv (+ offset 48) (elf-segment-align seg) byte-order))
553
554(define (write-elf-program-header bv offset byte-order word-size seg)
555 ((case word-size
556 ((4) write-elf32-program-header)
557 ((8) write-elf64-program-header)
558 (else (error "invalid word size" word-size)))
559 bv offset byte-order seg))
560
561(define (elf-program-header-len word-size)
562 (case word-size
563 ((4) 32)
564 ((8) 56)
565 (else (error "bad word size" word-size))))
566
567(define (elf-segment elf n)
568 (if (not (< -1 n (elf-phnum elf)))
569 (error "bad segment number" n))
570 ((case (elf-word-size elf)
571 ((4) parse-elf32-program-header)
572 ((8) parse-elf64-program-header)
573 (else (error "unhandled pointer size")))
574 n
575 (elf-bytes elf)
576 (+ (elf-phoff elf) (* n (elf-phentsize elf)))
577 (elf-byte-order elf)))
578
579(define (elf-segments elf)
580 (let lp ((n (elf-phnum elf)) (out '()))
581 (if (zero? n)
582 out
583 (lp (1- n) (cons (elf-segment elf (1- n)) out)))))
584
585(define-record-type <elf-section>
586 (make-elf-section index name type flags
587 addr offset size link info addralign entsize)
588 elf-section?
589 (index elf-section-index)
590 (name elf-section-name)
591 (type elf-section-type)
592 (flags elf-section-flags)
593 (addr elf-section-addr)
594 (offset elf-section-offset)
595 (size elf-section-size)
596 (link elf-section-link)
597 (info elf-section-info)
598 (addralign elf-section-addralign)
599 (entsize elf-section-entsize))
600
601(define* (make-elf-section* #:key (index SHN_UNDEF) (name 0) (type SHT_PROGBITS)
602 (flags SHF_ALLOC) (addr 0) (offset 0) (size 0)
603 (link 0) (info 0) (addralign 8) (entsize 0))
604 (make-elf-section index name type flags addr offset size link info addralign
605 entsize))
606
607;; typedef struct {
608;; uint32_t sh_name;
609;; uint32_t sh_type;
610;; uint32_t sh_flags;
611;; Elf32_Addr sh_addr;
612;; Elf32_Off sh_offset;
613;; uint32_t sh_size;
614;; uint32_t sh_link;
615;; uint32_t sh_info;
616;; uint32_t sh_addralign;
617;; uint32_t sh_entsize;
618;; } Elf32_Shdr;
619
620(define (parse-elf32-section-header index bv offset byte-order)
621 (if (<= (+ offset 40) (bytevector-length bv))
622 (make-elf-section index
623 (bytevector-u32-ref bv offset byte-order)
624 (bytevector-u32-ref bv (+ offset 4) byte-order)
625 (bytevector-u32-ref bv (+ offset 8) byte-order)
626 (bytevector-u32-ref bv (+ offset 12) byte-order)
627 (bytevector-u32-ref bv (+ offset 16) byte-order)
628 (bytevector-u32-ref bv (+ offset 20) byte-order)
629 (bytevector-u32-ref bv (+ offset 24) byte-order)
630 (bytevector-u32-ref bv (+ offset 28) byte-order)
631 (bytevector-u32-ref bv (+ offset 32) byte-order)
632 (bytevector-u32-ref bv (+ offset 36) byte-order))
633 (error "corrupt ELF (offset out of range)" offset)))
634
635(define (write-elf32-section-header bv offset byte-order sec)
636 (bytevector-u32-set! bv offset (elf-section-name sec) byte-order)
637 (bytevector-u32-set! bv (+ offset 4) (elf-section-type sec) byte-order)
638 (bytevector-u32-set! bv (+ offset 8) (elf-section-flags sec) byte-order)
639 (bytevector-u32-set! bv (+ offset 12) (elf-section-addr sec) byte-order)
640 (bytevector-u32-set! bv (+ offset 16) (elf-section-offset sec) byte-order)
641 (bytevector-u32-set! bv (+ offset 20) (elf-section-size sec) byte-order)
642 (bytevector-u32-set! bv (+ offset 24) (elf-section-link sec) byte-order)
643 (bytevector-u32-set! bv (+ offset 28) (elf-section-info sec) byte-order)
644 (bytevector-u32-set! bv (+ offset 32) (elf-section-addralign sec) byte-order)
645 (bytevector-u32-set! bv (+ offset 36) (elf-section-entsize sec) byte-order))
646
647
648;; typedef struct {
649;; uint32_t sh_name;
650;; uint32_t sh_type;
651;; uint64_t sh_flags;
652;; Elf64_Addr sh_addr;
653;; Elf64_Off sh_offset;
654;; uint64_t sh_size;
655;; uint32_t sh_link;
656;; uint32_t sh_info;
657;; uint64_t sh_addralign;
658;; uint64_t sh_entsize;
659;; } Elf64_Shdr;
660
661(define (elf-section-header-len word-size)
662 (case word-size
663 ((4) 40)
664 ((8) 64)
665 (else (error "bad word size" word-size))))
666
667(define (elf-section-header-addr-offset word-size)
668 (case word-size
669 ((4) 12)
670 ((8) 16)
671 (else (error "bad word size" word-size))))
672
673(define (elf-section-header-offset-offset word-size)
674 (case word-size
675 ((4) 16)
676 ((8) 24)
677 (else (error "bad word size" word-size))))
678
679(define (parse-elf64-section-header index bv offset byte-order)
680 (if (<= (+ offset 64) (bytevector-length bv))
681 (make-elf-section index
682 (bytevector-u32-ref bv offset byte-order)
683 (bytevector-u32-ref bv (+ offset 4) byte-order)
684 (bytevector-u64-ref bv (+ offset 8) byte-order)
685 (bytevector-u64-ref bv (+ offset 16) byte-order)
686 (bytevector-u64-ref bv (+ offset 24) byte-order)
687 (bytevector-u64-ref bv (+ offset 32) byte-order)
688 (bytevector-u32-ref bv (+ offset 40) byte-order)
689 (bytevector-u32-ref bv (+ offset 44) byte-order)
690 (bytevector-u64-ref bv (+ offset 48) byte-order)
691 (bytevector-u64-ref bv (+ offset 56) byte-order))
692 (error "corrupt ELF (offset out of range)" offset)))
693
694(define (write-elf64-section-header bv offset byte-order sec)
695 (bytevector-u32-set! bv offset (elf-section-name sec) byte-order)
696 (bytevector-u32-set! bv (+ offset 4) (elf-section-type sec) byte-order)
697 (bytevector-u64-set! bv (+ offset 8) (elf-section-flags sec) byte-order)
698 (bytevector-u64-set! bv (+ offset 16) (elf-section-addr sec) byte-order)
699 (bytevector-u64-set! bv (+ offset 24) (elf-section-offset sec) byte-order)
700 (bytevector-u64-set! bv (+ offset 32) (elf-section-size sec) byte-order)
701 (bytevector-u32-set! bv (+ offset 40) (elf-section-link sec) byte-order)
702 (bytevector-u32-set! bv (+ offset 44) (elf-section-info sec) byte-order)
703 (bytevector-u64-set! bv (+ offset 48) (elf-section-addralign sec) byte-order)
704 (bytevector-u64-set! bv (+ offset 56) (elf-section-entsize sec) byte-order))
705
706(define (elf-section elf n)
707 (if (not (< -1 n (elf-shnum elf)))
708 (error "bad section number" n))
709 ((case (elf-word-size elf)
710 ((4) parse-elf32-section-header)
711 ((8) parse-elf64-section-header)
712 (else (error "unhandled pointer size")))
713 n
714 (elf-bytes elf)
715 (+ (elf-shoff elf) (* n (elf-shentsize elf)))
716 (elf-byte-order elf)))
717
718(define (write-elf-section-header bv offset byte-order word-size sec)
719 ((case word-size
720 ((4) write-elf32-section-header)
721 ((8) write-elf64-section-header)
722 (else (error "invalid word size" word-size)))
723 bv offset byte-order sec))
724
725(define (elf-sections elf)
726 (let lp ((n (elf-shnum elf)) (out '()))
727 (if (zero? n)
728 out
729 (lp (1- n) (cons (elf-section elf (1- n)) out)))))
730
731;;
732;; Section Types
733;;
734(define SHT_NULL 0) ; Section header table entry unused
735(define SHT_PROGBITS 1) ; Program data
736(define SHT_SYMTAB 2) ; Symbol table
737(define SHT_STRTAB 3) ; String table
738(define SHT_RELA 4) ; Relocation entries with addends
739(define SHT_HASH 5) ; Symbol hash table
740(define SHT_DYNAMIC 6) ; Dynamic linking information
741(define SHT_NOTE 7) ; Notes
742(define SHT_NOBITS 8) ; Program space with no data (bss)
743(define SHT_REL 9) ; Relocation entries, no addends
744(define SHT_SHLIB 10) ; Reserved
745(define SHT_DYNSYM 11) ; Dynamic linker symbol table
746(define SHT_INIT_ARRAY 14) ; Array of constructors
747(define SHT_FINI_ARRAY 15) ; Array of destructors
748(define SHT_PREINIT_ARRAY 16) ; Array of pre-constructors
749(define SHT_GROUP 17) ; Section group
750(define SHT_SYMTAB_SHNDX 18) ; Extended section indeces
751(define SHT_NUM 19) ; Number of defined types.
752(define SHT_LOOS #x60000000) ; Start OS-specific.
753(define SHT_HIOS #x6fffffff) ; End OS-specific type
754(define SHT_LOPROC #x70000000) ; Start of processor-specific
755(define SHT_HIPROC #x7fffffff) ; End of processor-specific
756(define SHT_LOUSER #x80000000) ; Start of application-specific
757(define SHT_HIUSER #x8fffffff) ; End of application-specific
758
759;;
760;; Section Flags
761;;
762(define SHF_WRITE (ash 1 0)) ; Writable
763(define SHF_ALLOC (ash 1 1)) ; Occupies memory during execution
764(define SHF_EXECINSTR (ash 1 2)) ; Executable
765(define SHF_MERGE (ash 1 4)) ; Might be merged
766(define SHF_STRINGS (ash 1 5)) ; Contains nul-terminated strings
767(define SHF_INFO_LINK (ash 1 6)) ; `sh_info' contains SHT index
768(define SHF_LINK_ORDER (ash 1 7)) ; Preserve order after combining
769(define SHF_OS_NONCONFORMING (ash 1 8)) ; Non-standard OS specific handling required
770(define SHF_GROUP (ash 1 9)) ; Section is member of a group.
771(define SHF_TLS (ash 1 10)) ; Section hold thread-local data.
772
773;;
774;; Dynamic entry types. The DT_GUILE types are non-standard.
775;;
776(define DT_NULL 0) ; Marks end of dynamic section
777(define DT_NEEDED 1) ; Name of needed library
778(define DT_PLTRELSZ 2) ; Size in bytes of PLT relocs
779(define DT_PLTGOT 3) ; Processor defined value
780(define DT_HASH 4) ; Address of symbol hash table
781(define DT_STRTAB 5) ; Address of string table
782(define DT_SYMTAB 6) ; Address of symbol table
783(define DT_RELA 7) ; Address of Rela relocs
784(define DT_RELASZ 8) ; Total size of Rela relocs
785(define DT_RELAENT 9) ; Size of one Rela reloc
786(define DT_STRSZ 10) ; Size of string table
787(define DT_SYMENT 11) ; Size of one symbol table entry
788(define DT_INIT 12) ; Address of init function
789(define DT_FINI 13) ; Address of termination function
790(define DT_SONAME 14) ; Name of shared object
791(define DT_RPATH 15) ; Library search path (deprecated)
792(define DT_SYMBOLIC 16) ; Start symbol search here
793(define DT_REL 17) ; Address of Rel relocs
794(define DT_RELSZ 18) ; Total size of Rel relocs
795(define DT_RELENT 19) ; Size of one Rel reloc
796(define DT_PLTREL 20) ; Type of reloc in PLT
797(define DT_DEBUG 21) ; For debugging ; unspecified
798(define DT_TEXTREL 22) ; Reloc might modify .text
799(define DT_JMPREL 23) ; Address of PLT relocs
800(define DT_BIND_NOW 24) ; Process relocations of object
801(define DT_INIT_ARRAY 25) ; Array with addresses of init fct
802(define DT_FINI_ARRAY 26) ; Array with addresses of fini fct
803(define DT_INIT_ARRAYSZ 27) ; Size in bytes of DT_INIT_ARRAY
804(define DT_FINI_ARRAYSZ 28) ; Size in bytes of DT_FINI_ARRAY
805(define DT_RUNPATH 29) ; Library search path
806(define DT_FLAGS 30) ; Flags for the object being loaded
807(define DT_ENCODING 32) ; Start of encoded range
808(define DT_PREINIT_ARRAY 32) ; Array with addresses of preinit fc
809(define DT_PREINIT_ARRAYSZ 33) ; size in bytes of DT_PREINIT_ARRAY
810(define DT_NUM 34) ; Number used
811(define DT_LOGUILE #x37146000) ; Start of Guile-specific
812(define DT_GUILE_GC_ROOT #x37146000) ; Offset of GC roots
813(define DT_GUILE_GC_ROOT_SZ #x37146001) ; Size in machine words of GC roots
814(define DT_GUILE_ENTRY #x37146002) ; Address of entry thunk
815(define DT_GUILE_VM_VERSION #x37146003) ; Bytecode version
816(define DT_GUILE_FRAME_MAPS #x37146004) ; Offset of .guile.frame-maps
817(define DT_HIGUILE #x37146fff) ; End of Guile-specific
818(define DT_LOOS #x6000000d) ; Start of OS-specific
819(define DT_HIOS #x6ffff000) ; End of OS-specific
820(define DT_LOPROC #x70000000) ; Start of processor-specific
821(define DT_HIPROC #x7fffffff) ; End of processor-specific
822
823
824(define (string-table-ref bv offset)
825 (let lp ((end offset))
826 (if (zero? (bytevector-u8-ref bv end))
827 (let ((out (make-bytevector (- end offset))))
828 (bytevector-copy! bv offset out 0 (- end offset))
829 (utf8->string out))
830 (lp (1+ end)))))
831
832(define (elf-section-by-name elf name)
833 (let ((off (elf-section-offset (elf-section elf (elf-shstrndx elf)))))
834 (let lp ((n (elf-shnum elf)))
835 (and (> n 0)
836 (let ((section (elf-section elf (1- n))))
837 (if (equal? (string-table-ref (elf-bytes elf)
838 (+ off (elf-section-name section)))
839 name)
840 section
841 (lp (1- n))))))))
842
843(define (elf-sections-by-name elf)
844 (let* ((sections (elf-sections elf))
845 (off (elf-section-offset (list-ref sections (elf-shstrndx elf)))))
846 (map (lambda (section)
847 (cons (string-table-ref (elf-bytes elf)
848 (+ off (elf-section-name section)))
849 section))
850 sections)))
851
852(define-record-type <elf-symbol>
853 (make-elf-symbol name value size info other shndx)
854 elf-symbol?
855 (name elf-symbol-name)
856 (value elf-symbol-value)
857 (size elf-symbol-size)
858 (info elf-symbol-info)
859 (other elf-symbol-other)
860 (shndx elf-symbol-shndx))
861
862(define* (make-elf-symbol* #:key (name 0) (value 0) (size 0)
863 (binding STB_LOCAL) (type STT_NOTYPE)
864 (info (logior (ash binding 4) type))
865 (visibility STV_DEFAULT) (other visibility)
866 (shndx SHN_UNDEF))
867 (make-elf-symbol name value size info other shndx))
868
869;; typedef struct {
870;; uint32_t st_name;
871;; Elf32_Addr st_value;
872;; uint32_t st_size;
873;; unsigned char st_info;
874;; unsigned char st_other;
875;; uint16_t st_shndx;
876;; } Elf32_Sym;
877
878(define (elf-symbol-len word-size)
879 (case word-size
880 ((4) 16)
881 ((8) 24)
882 (else (error "bad word size" word-size))))
883
884(define (elf-symbol-value-offset word-size)
885 (case word-size
886 ((4) 4)
887 ((8) 8)
888 (else (error "bad word size" word-size))))
889
890(define (parse-elf32-symbol bv offset stroff byte-order)
891 (if (<= (+ offset 16) (bytevector-length bv))
892 (make-elf-symbol (let ((name (bytevector-u32-ref bv offset byte-order)))
893 (if stroff
894 (string-table-ref bv (+ stroff name))
895 name))
896 (bytevector-u32-ref bv (+ offset 4) byte-order)
897 (bytevector-u32-ref bv (+ offset 8) byte-order)
898 (bytevector-u8-ref bv (+ offset 12))
899 (bytevector-u8-ref bv (+ offset 13))
900 (bytevector-u16-ref bv (+ offset 14) byte-order))
901 (error "corrupt ELF (offset out of range)" offset)))
902
903(define (write-elf32-symbol bv offset byte-order sym)
904 (bytevector-u32-set! bv offset (elf-symbol-name sym) byte-order)
905 (bytevector-u32-set! bv (+ offset 4) (elf-symbol-value sym) byte-order)
906 (bytevector-u32-set! bv (+ offset 8) (elf-symbol-size sym) byte-order)
907 (bytevector-u8-set! bv (+ offset 12) (elf-symbol-info sym))
908 (bytevector-u8-set! bv (+ offset 13) (elf-symbol-other sym))
909 (bytevector-u16-set! bv (+ offset 14) (elf-symbol-shndx sym) byte-order))
910
911;; typedef struct {
912;; uint32_t st_name;
913;; unsigned char st_info;
914;; unsigned char st_other;
915;; uint16_t st_shndx;
916;; Elf64_Addr st_value;
917;; uint64_t st_size;
918;; } Elf64_Sym;
919
920(define (parse-elf64-symbol bv offset stroff byte-order)
921 (if (<= (+ offset 24) (bytevector-length bv))
922 (make-elf-symbol (let ((name (bytevector-u32-ref bv offset byte-order)))
923 (if stroff
924 (string-table-ref bv (+ stroff name))
925 name))
926 (bytevector-u64-ref bv (+ offset 8) byte-order)
927 (bytevector-u64-ref bv (+ offset 16) byte-order)
928 (bytevector-u8-ref bv (+ offset 4))
929 (bytevector-u8-ref bv (+ offset 5))
930 (bytevector-u16-ref bv (+ offset 6) byte-order))
931 (error "corrupt ELF (offset out of range)" offset)))
932
933(define (write-elf64-symbol bv offset byte-order sym)
934 (bytevector-u32-set! bv offset (elf-symbol-name sym) byte-order)
935 (bytevector-u8-set! bv (+ offset 4) (elf-symbol-info sym))
936 (bytevector-u8-set! bv (+ offset 5) (elf-symbol-other sym))
937 (bytevector-u16-set! bv (+ offset 6) (elf-symbol-shndx sym) byte-order)
938 (bytevector-u64-set! bv (+ offset 8) (elf-symbol-value sym) byte-order)
939 (bytevector-u64-set! bv (+ offset 16) (elf-symbol-size sym) byte-order))
940
941(define (write-elf-symbol bv offset byte-order word-size sym)
942 ((case word-size
943 ((4) write-elf32-symbol)
944 ((8) write-elf64-symbol)
945 (else (error "invalid word size" word-size)))
946 bv offset byte-order sym))
947
948(define (elf-symbol-table-len section)
949 (let ((len (elf-section-size section))
950 (entsize (elf-section-entsize section)))
951 (unless (and (not (zero? entsize)) (zero? (modulo len entsize)))
952 (error "bad symbol table" section))
953 (/ len entsize)))
954
955(define* (elf-symbol-table-ref elf section n #:optional strtab)
956 (let ((bv (elf-bytes elf))
957 (byte-order (elf-byte-order elf))
958 (stroff (and strtab (elf-section-offset strtab)))
959 (base (elf-section-offset section))
960 (len (elf-section-size section))
961 (entsize (elf-section-entsize section)))
962 (unless (<= (* (1+ n) entsize) len)
963 (error "out of range symbol table access" section n))
964 (case (elf-word-size elf)
965 ((4)
966 (unless (<= 16 entsize)
967 (error "bad entsize for symbol table" section))
968 (parse-elf32-symbol bv (+ base (* n entsize)) stroff byte-order))
969 ((8)
970 (unless (<= 24 entsize)
971 (error "bad entsize for symbol table" section))
972 (parse-elf64-symbol bv (+ base (* n entsize)) stroff byte-order))
973 (else (error "bad word size" elf)))))
974
975;; Legal values for ST_BIND subfield of st_info (symbol binding).
976
977(define STB_LOCAL 0) ; Local symbol
978(define STB_GLOBAL 1) ; Global symbol
979(define STB_WEAK 2) ; Weak symbol
980(define STB_NUM 3) ; Number of defined types.
981(define STB_LOOS 10) ; Start of OS-specific
982(define STB_GNU_UNIQUE 10) ; Unique symbol.
983(define STB_HIOS 12) ; End of OS-specific
984(define STB_LOPROC 13) ; Start of processor-specific
985(define STB_HIPROC 15) ; End of processor-specific
986
987;; Legal values for ST_TYPE subfield of st_info (symbol type).
988
989(define STT_NOTYPE 0) ; Symbol type is unspecified
990(define STT_OBJECT 1) ; Symbol is a data object
991(define STT_FUNC 2) ; Symbol is a code object
992(define STT_SECTION 3) ; Symbol associated with a section
993(define STT_FILE 4) ; Symbol's name is file name
994(define STT_COMMON 5) ; Symbol is a common data object
995(define STT_TLS 6) ; Symbol is thread-local data objec
996(define STT_NUM 7) ; Number of defined types.
997(define STT_LOOS 10) ; Start of OS-specific
998(define STT_GNU_IFUNC 10) ; Symbol is indirect code object
999(define STT_HIOS 12) ; End of OS-specific
1000(define STT_LOPROC 13) ; Start of processor-specific
1001(define STT_HIPROC 15) ; End of processor-specific
1002
1003;; Symbol visibility specification encoded in the st_other field.
1004
1005(define STV_DEFAULT 0) ; Default symbol visibility rules
1006(define STV_INTERNAL 1) ; Processor specific hidden class
1007(define STV_HIDDEN 2) ; Sym unavailable in other modules
1008(define STV_PROTECTED 3) ; Not preemptible, not exported
1009
1010(define (elf-symbol-binding sym)
1011 (ash (elf-symbol-info sym) -4))
1012
1013(define (elf-symbol-type sym)
1014 (logand (elf-symbol-info sym) #xf))
1015
1016(define (elf-symbol-visibility sym)
1017 (logand (elf-symbol-other sym) #x3))
1018
1019(define NT_GNU_ABI_TAG 1)
1020(define NT_GNU_HWCAP 2)
1021(define NT_GNU_BUILD_ID 3)
1022(define NT_GNU_GOLD_VERSION 4)
1023
1024(define-record-type <elf-note>
1025 (make-elf-note name desc type)
1026 elf-note?
1027 (name elf-note-name)
1028 (desc elf-note-desc)
1029 (type elf-note-type))
1030
1031(define (parse-elf-note elf section)
1032 (let ((bv (elf-bytes elf))
1033 (byte-order (elf-byte-order elf))
1034 (offset (elf-section-offset section)))
1035 (unless (<= (+ offset 12) (bytevector-length bv))
1036 (error "corrupt ELF (offset out of range)" offset))
1037 (let ((namesz (bytevector-u32-ref bv offset byte-order))
1038 (descsz (bytevector-u32-ref bv (+ offset 4) byte-order))
1039 (type (bytevector-u32-ref bv (+ offset 8) byte-order)))
1040 (unless (<= (+ offset 12 namesz descsz) (bytevector-length bv))
1041 (error "corrupt ELF (offset out of range)" offset))
1042 (let ((name (make-bytevector (1- namesz)))
1043 (desc (make-bytevector descsz)))
1044 (bytevector-copy! bv (+ offset 12) name 0 (1- namesz))
1045 (bytevector-copy! bv (+ offset 12 namesz) desc 0 descsz)
1046 (make-elf-note (utf8->string name) desc type)))))