source: release/1.9/source/library/elf.lisp @ 15706

Last change on this file since 15706 was 14981, checked in by rme, 8 years ago

Nicer ELF function names in some circumstances.

File size: 21.9 KB
Line 
1;;; Copyright 2009 Clozure Associates
2;;; This file is part of Clozure CL. 
3;;;
4;;; Clozure CL is licensed under the terms of the Lisp Lesser GNU
5;;; Public License , known as the LLGPL and distributed with Clozure
6;;; CL as the file "LICENSE".  The LLGPL consists of a preamble and
7;;; the LGPL, which is distributed with Clozure CL as the file "LGPL".
8;;; Where these conflict, the preamble takes precedence.
9;;;
10;;; Clozure CL is referenced in the preamble as the "LIBRARY."
11;;;
12;;; The LLGPL is also available online at
13;;; http://opensource.franz.com/preamble.html
14
15(in-package "CCL")
16
17(eval-when (:compile-toplevel :execute)
18  (use-interface-dir :elf))
19
20
21(defloadvar *readonly-area*
22    (do-consing-areas (a)
23      (when (eql (%fixnum-ref a target::area.code)
24                 ccl::area-readonly)
25        (return a))))
26
27;;; String tables: used both for symbol names and for section names.
28(defstruct elf-string-table
29  (hash (make-hash-table :test #'equal))
30  (string (make-array 100 :element-type '(unsigned-byte 8) :fill-pointer 1 :adjustable t)))
31
32;;; Collect info about Elf symbols.
33(defstruct elf-symbol-table
34  (strings (make-elf-string-table))
35  data                                  ; foreign pointer
36  nsyms
37  )
38
39;;; Wrapper around libelf's "elf" pointer
40(defstruct elf-object
41  libelf-pointer
42  fd
43  pathname
44  )
45
46
47;;; Is libelf thread-safe ?  Who knows, there's no
48;;; documentation ...
49(defun libelf-error-string (&optional (errnum -1))
50  (let* ((p (#_elf_errmsg errnum)))
51    (if (%null-ptr-p p)
52      (format nil "ELF error ~d" errnum)
53      (%get-cstring p))))
54
55(defloadvar *checked-libelf-version* nil)
56
57(defun check-libelf-version ()
58  (or *checked-libelf-version*
59      (progn
60        (open-shared-library "libelf.so")
61        (let* ((version (#_elf_version #$EV_CURRENT)))
62          (if (eql #$EV_NONE version)
63            (error "ELF library initialization failed: ~a" (libelf-error-string)))
64          (setq *checked-libelf-version* version)))))
65
66
67;;; Prepate to create an ELF object file at PATHNAME, overwriting
68;;; whatever might have been there.
69(defun create-elf-object (pathname)
70  (let* ((namestring (native-translated-namestring pathname))
71         (fd (ccl::fd-open namestring
72                           (logior #$O_RDWR #$O_CREAT #$O_TRUNC)
73                           #o755)))
74    (if (< fd 0)
75      (signal-file-error fd pathname)
76      (progn
77        (check-libelf-version)
78        (let* ((ptr (#_elf_begin fd #$ELF_C_WRITE +null-ptr+)))
79          (if (%null-ptr-p ptr)
80            (error "Can't initialize libelf object for ~s: ~a"
81                   pathname (libelf-error-string))
82            (make-elf-object :libelf-pointer (assert-pointer-type ptr :<E>lf)
83                             :fd fd
84                             :pathname pathname)))))))
85
86(defun elf-end (object)
87  (#_elf_end (elf-object-libelf-pointer object))
88  (setf (elf-object-libelf-pointer object) nil
89        (elf-object-fd object) nil))
90
91(defun new-elf-file-header (object format type machine)
92  (let* ((ehdr (#+64-bit-target #_elf64_newehdr #+32-bit-target #_elf32_newehdr (elf-object-libelf-pointer object))))
93    (if (%null-ptr-p ehdr)
94      (error "Can't create ELF file header for ~s: ~a"
95             (elf-object-pathname object)
96             (libelf-error-string))
97      (progn
98        (setf (paref (pref ehdr
99                           #+64-bit-target :<E>lf64_<E>hdr.e_ident
100                           #+32-bit-target :<E>lf32_<E>hdr.e_ident) (:* :unsigned-char) #$EI_DATA) format
101              (pref ehdr
102                    #+64-bit-target :<E>lf64_<E>hdr.e_machine
103                    #+32-bit-target :<E>lf32_<E>hdr.e_machine) machine
104              (pref ehdr
105                    #+64-bit-target :<E>lf64_<E>hdr.e_type
106                    #+32-bit-target :<E>lf32_<E>hdr.e_type) type
107              (pref ehdr
108                    #+64-bit-target :<E>lf64_<E>hdr.e_version
109                    #+32-bit-target :<E>lf32_<E>hdr.e_version) *checked-libelf-version*)
110        (assert-pointer-type ehdr
111                             #+64-bit-target :<E>lf64_<E>hdr
112                             #+32-bit-target :<E>lf32_<E>hdr)))))
113
114(defun new-elf-program-header (object &optional (count 1))
115  (let* ((phdr (#+64-bit-target #_elf64_newphdr #+32-bit-target #_elf32_newphdr (elf-object-libelf-pointer object) count)))
116    (if (%null-ptr-p phdr)
117      (error "Can't create ELF program header for ~s: ~a"
118             (elf-object-pathname object)
119             (libelf-error-string))
120      (assert-pointer-type phdr
121                           #+64-bit-target :<E>lf64_<P>hdr
122                           #+32-bit-target :<E>lf32_<P>hdr))))
123
124(defun new-elf-section (object)
125  (let* ((scn (#_elf_newscn (elf-object-libelf-pointer object))))
126    (if (%null-ptr-p scn)
127      (error "Can' create ELF section for ~s: ~a"
128             (elf-object-pathname object)
129             (libelf-error-string))
130      (assert-pointer-type scn :<E>lf_<S>cn))))
131
132(defun elf-section-header-for-section (object section)
133  (let* ((shdr (#+64-bit-target #_elf64_getshdr #+32-bit-target #_elf32_getshdr  section)))
134    (if (%null-ptr-p shdr)
135      (error "Can' obtain ELF section header for ~s: ~a"
136             (elf-object-pathname object)
137             (libelf-error-string))
138      (assert-pointer-type shdr
139                           #+64-bit-target :<E>lf64_<S>hdr
140                           #+32-bit-target :<E>lf32_<S>hdr))))
141
142(defun elf-data-pointer-for-section (object section)
143  (let* ((data (#_elf_newdata section)))
144    (if (%null-ptr-p data)
145      (error "Can' obtain ELF data pointer for ~s: ~a"
146             (elf-object-pathname object)
147             (libelf-error-string))
148      (assert-pointer-type data :<E>lf_<D>ata))))
149                   
150
151(defun elf-register-string (string table)
152  (let* ((hash (elf-string-table-hash table))
153         (s (elf-string-table-string table)))
154    (when (gethash string hash)
155      (format t "~& duplicate: ~s" string))
156    (or (gethash string hash)
157        (setf (gethash string hash)
158              (let* ((n (length s)))
159                (dotimes (i (length string) (progn (vector-push-extend 0 s) n))
160                  (let* ((code (char-code (char string i))))
161                    (declare (type (mod #x110000) code))
162                    (if (> code 255)
163                      (vector-push-extend (char-code #\sub) s)
164                      (vector-push-extend code s)))))))))
165
166
167(defun elf-lisp-function-name (f)
168  (let* ((name (function-name f)))
169    (if (and (symbolp name)
170             (eq f (fboundp name)))
171      (with-standard-io-syntax
172        (format nil "~s" name))
173      (let ((str (format nil "~s" f)))
174        (subseq (nsubstitute #\0 #\# (nsubstitute #\. #\Space str)) 1)))))
175
176
177#+x86-target
178(defun collect-elf-static-functions ()
179  (collect ((functions))
180    (purify)
181    (block walk
182      (%map-areas (lambda (o)
183                    (when (typep o
184                                 #+x8664-target 'function-vector
185                                 #-x8664-target 'function)
186                      (functions (function-vector-to-function o))))
187                  :readonly
188                  ))
189    (functions)))
190
191#+(or arm-target ppc-target)
192(defun collect-elf-static-functions ()
193  (ccl::purify)
194  (multiple-value-bind (pure-low pure-high)
195      (ccl::do-gc-areas (a)
196        (when (eql(ccl::%fixnum-ref a target::area.code)
197                  ccl::area-readonly)
198          (return
199            (values (ash (ccl::%fixnum-ref a target::area.low) target::fixnumshift)
200                    (ash (ccl::%fixnum-ref a target::area.active) target::fixnumshift)))))
201    (let* ((hash (make-hash-table :test #'eq))
202           (code-vector-index #+ppc-target 0 #+arm-target 1))
203      (ccl::%map-lfuns #'(lambda (f)
204                           (let* ((code-vector  (ccl:uvref f code-vector-index))
205                                  (startaddr (+ (ccl::%address-of code-vector)
206                                                target::misc-data-offset)))
207                             (when (and (>= startaddr pure-low)
208                                        (< startaddr pure-high))
209                               (push f (gethash code-vector hash))))))
210      (let* ((n 0))
211        (declare (fixnum n))
212        (maphash #'(lambda (k v)
213                     (declare (ignore k))
214                     (if (null (cdr v))
215                       (incf n)))
216                 hash)
217        (let* ((functions ()))
218          (maphash #'(lambda (k v)
219                       (declare (ignore k))
220                       (when (null (cdr v))
221                         (push (car v) functions)))
222                   hash)
223          (sort functions
224                #'(lambda (x y)
225                    (< (ccl::%address-of (uvref x code-vector-index))
226                       (ccl::%address-of (uvref y code-vector-index))))))))))
227
228(defun register-elf-functions (section-number)
229  (let* ((functions (collect-elf-static-functions))
230         (n (length functions))
231         (data (#_calloc (1+ n) (record-length #+64-bit-target :<E>lf64_<S>ym
232                                               #+32-bit-target :<E>lf32_<S>ym)))
233         (string-table (make-elf-string-table)))
234    (declare (fixnum n))
235    (do* ((i 0 (1+ i))
236          (p (%inc-ptr data
237                       (record-length #+64-bit-target :<E>lf64_<S>ym
238                                      #+32-bit-target :<E>lf32_<S>ym))
239             (progn (%incf-ptr p
240                               (record-length #+64-bit-target :<E>lf64_<S>ym
241                                              #+32-bit-target :<E>lf32_<S>ym))
242                    p))
243          (f (pop functions) (pop functions)))
244         ((= i n)
245          (make-elf-symbol-table :strings string-table :data data :nsyms n))
246      (declare (fixnum n))
247      (setf (pref p
248                  #+64-bit-target :<E>lf64_<S>ym.st_name
249                  #+32-bit-target :<E>lf32_<S>ym.st_name)
250            (elf-register-string (elf-lisp-function-name f) string-table)
251            (pref p
252                  #+64-bit-target :<E>lf64_<S>ym.st_info
253                  #+32-bit-target :<E>lf32_<S>ym.st_info)
254            (logior (ash #$STB_GLOBAL 4) #$STT_FUNC)
255            (pref p
256                  #+64-bit-target :<E>lf64_<S>ym.st_shndx
257                  #+32-bit-target :<E>lf32_<S>ym.st_shndx) section-number
258            (pref p
259                  #+64-bit-target :<E>lf64_<S>ym.st_value
260                  #+32-bit-target :<E>lf32_<S>ym.st_value)
261            #+x86-target (%address-of f)
262            #+ppc-target (- (%address-of (uvref f 0)) (- ppc::fulltag-misc ppc::node-size))
263            #+arm-target (- (%address-of (uvref f 1)) (- arm::fulltag-misc arm::node-size))
264            (pref p
265                  #+64-bit-target :<E>lf64_<S>ym.st_size
266                  #+32-bit-target :<E>lf32_<S>ym.st_size)
267            #+x86-target (1+ (ash (1- (%function-code-words f)) target::word-shift))
268            #+ppc-target (ash (uvsize (uvref f 0)) ppc::word-shift)
269            #+arm-target (ash (uvsize (uvref f 1)) arm::word-shift)
270            ))))
271
272(defun elf-section-index (section)
273  (#_elf_ndxscn section))
274
275(defun elf-set-shstrab-section (object scn)
276  #+freebsd-target
277  (#_elf_setshstrndx (elf-object-libelf-pointer object) (elf-section-index scn))
278  #-freebsd-target
279  (declare (ignore object scn)))
280
281
282(defun elf-init-section-data-from-string-table (object section string-table)
283  (let* ((strings-data (elf-data-pointer-for-section object section))
284         (s (elf-string-table-string string-table))
285         (bytes (array-data-and-offset s))
286         (n (length s))
287         (buf (#_malloc n)))
288    (%copy-ivector-to-ptr bytes 0 buf 0 n)
289    (setf (pref strings-data :<E>lf_<D>ata.d_align) 1
290          (pref strings-data :<E>lf_<D>ata.d_off) 0
291          (pref strings-data :<E>lf_<D>ata.d_type) #$ELF_T_BYTE
292          (pref strings-data :<E>lf_<D>ata.d_version) #$EV_CURRENT
293          (pref strings-data :<E>lf_<D>ata.d_size) n
294          (pref strings-data :<E>lf_<D>ata.d_buf) buf)
295    n))
296
297(defun elf-init-symbol-section-from-symbol-table (object section symbols)
298  (let* ((symbols-data (elf-data-pointer-for-section object section))
299         (buf (elf-symbol-table-data symbols))
300         (nsyms (elf-symbol-table-nsyms symbols) )
301         (n (* (1+ nsyms) (record-length #+64-bit-target :<E>lf64_<S>ym
302                                         #+32-bit-target :<E>lf32_<S>ym))))
303    (setf (pref symbols-data :<E>lf_<D>ata.d_align) 8
304          (pref symbols-data :<E>lf_<D>ata.d_off) 0
305          (pref symbols-data :<E>lf_<D>ata.d_type) #$ELF_T_SYM
306          (pref symbols-data :<E>lf_<D>ata.d_version) #$EV_CURRENT
307          (pref symbols-data :<E>lf_<D>ata.d_size) n
308          (pref symbols-data :<E>lf_<D>ata.d_buf) buf)
309    nsyms))
310
311(defun elf-make-empty-data-for-section (object section &optional (size 0))
312  (let* ((data (elf-data-pointer-for-section object section))
313         (buf +null-ptr+))
314    (setf (pref data :<E>lf_<D>ata.d_align) 0
315          (pref data :<E>lf_<D>ata.d_off) 0
316          (pref data :<E>lf_<D>ata.d_type) #$ELF_T_BYTE
317          (pref data :<E>lf_<D>ata.d_version) #$EV_CURRENT
318          (pref data :<E>lf_<D>ata.d_size) size
319          (pref data :<E>lf_<D>ata.d_buf) buf)
320    0))
321 
322
323(defun elf-flag-phdr (object cmd flags)
324  (#_elf_flagphdr (elf-object-libelf-pointer object) cmd flags))
325
326(defun elf-update (object cmd)
327  (let* ((size (#_elf_update (elf-object-libelf-pointer object) cmd)))
328    (if (< size 0)
329      (error "elf_update failed for for ~s: ~a"
330             (elf-object-pathname object)
331             (libelf-error-string))
332      size)))
333
334(defun fixup-lisp-section-offset (fd eof sectnum)
335  (fd-lseek fd 0 #$SEEK_SET)
336  (rlet ((fhdr #+64-bit-target :<E>lf64_<E>hdr
337               #+32-bit-target :<E>lf32_<E>hdr)
338         (shdr #+64-bit-target :<E>lf64_<S>hdr
339               #+32-bit-target :<E>lf32_<S>hdr))
340    (fd-read fd fhdr (record-length #+64-bit-target :<E>lf64_<E>hdr
341                                    #+32-bit-target :<E>lf32_<E>hdr))
342    (let* ((pos (+ (pref fhdr #+64-bit-target :<E>lf64_<E>hdr.e_shoff
343                         #+32-bit-target :<E>lf32_<E>hdr.e_shoff)
344                   (* sectnum (pref fhdr #+64-bit-target :<E>lf64_<E>hdr.e_shentsize
345                                    #+32-bit-target :<E>lf32_<E>hdr.e_shentsize)))))
346      (fd-lseek fd pos #$SEEK_SET)
347      (fd-read fd shdr (record-length #+64-bit-target :<E>lf64_<S>hdr
348                                      #+32-bit-target :<E>lf32_<S>hdr))
349      ;; On 64-bit platforms, the section data precedes the image
350      ;; header; on 32-bit platforms, the image header and image
351      ;; section table precede the image data for the first (static)
352      ;; section.  With alignment, the header/section headers are
353      ;; one 4K page, and the static section size is 8K ...
354      (setf (pref shdr #+64-bit-target :<E>lf64_<S>hdr.sh_offset
355                  #+32-bit-target :<E>lf32_<S>hdr.sh_offset)
356            (+ #+32-bit-target #x1000 #+64-bit-target 0  #x2000 (logandc2 (+ eof 4095) 4095))) 
357      (setf (pref shdr #+64-bit-target :<E>lf64_<S>hdr.sh_type
358                  #+32-bit-target :<E>lf32_<S>hdr.sh_type)
359            #$SHT_PROGBITS)
360      (fd-lseek fd pos #$SEEK_SET)
361      (fd-write fd shdr (record-length #+64-bit-target :<E>lf64_<S>hdr
362                                       #+32-bit-target :<E>lf32_<S>hdr))
363      t)))
364 
365(defun write-elf-symbols-to-file (pathname)
366  (let* ((object (create-elf-object pathname))
367         (file-header (new-elf-file-header object
368                                           #+little-endian-target #$ELFDATA2LSB
369                                           #+big-endian-target #$ELFDATA2MSB
370                                           #$ET_DYN
371                                           #+x8664-target #$EM_X86_64
372                                           #+x8632-target #$EM_386
373                                           #+ppc32-target #$EM_PPC
374                                           #+ppc64-target #$EM_PPC64
375                                           #+arm-target #$EM_ARM
376                                           ))
377         (program-header (new-elf-program-header object))
378         (lisp-section (new-elf-section object))
379         (symbols-section (new-elf-section object))
380         (strings-section (new-elf-section object))
381         (shstrtab-section (new-elf-section object))
382         (prelink-id-section (new-elf-section object))
383         (section-names (make-elf-string-table))
384         (lisp-section-index (elf-section-index lisp-section))
385         (symbols (register-elf-functions lisp-section-index))
386         (lisp-section-header (elf-section-header-for-section object lisp-section))
387         (symbols-section-header (elf-section-header-for-section object symbols-section))
388         (strings-section-header (elf-section-header-for-section object strings-section))
389         (shstrtab-section-header (elf-section-header-for-section object shstrtab-section))
390         (prelink-id-section-header (elf-section-header-for-section object prelink-id-section)))
391   
392    (setf (pref file-header #+64-bit-target :<E>lf64_<E>hdr.e_shstrndx
393                #+32-bit-target :<E>lf32_<E>hdr.e_shstrndx) (elf-section-index shstrtab-section))
394    (setf (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_name
395                #+32-bit-target :<E>lf32_<S>hdr.sh_name) (elf-register-string ".lisp" section-names)
396          (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_type
397                #+32-bit-target :<E>lf32_<S>hdr.sh_type) #$SHT_NOBITS
398          (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_flags
399                #+32-bit-target :<E>lf32_<S>hdr.sh_flags) (logior #$SHF_WRITE #$SHF_ALLOC #$SHF_EXECINSTR)
400          (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_addr
401                #+32-bit-target :<E>lf32_<S>hdr.sh_addr) (ash (%fixnum-ref *readonly-area* target::area.low) target::fixnumshift)
402          (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_size
403                #+32-bit-target :<E>lf32_<S>hdr.sh_size) (ash (- (%fixnum-ref *readonly-area* target::area.active) (%fixnum-ref *readonly-area* target::area.low) )target::fixnumshift)
404          (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_offset
405                #+32-bit-target :<E>lf32_<S>hdr.sh_offset) 0
406          (pref lisp-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_addralign
407                #+32-bit-target :<E>lf32_<S>hdr.sh_addralign) 1)
408    (setf (pref symbols-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_name
409                #+32-bit-target :<E>lf32_<S>hdr.sh_name) (elf-register-string ".symtab" section-names)
410          (pref symbols-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_type
411                #+32-bit-target :<E>lf32_<S>hdr.sh_type) #$SHT_SYMTAB
412          (pref symbols-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_entsize
413                #+32-bit-target :<E>lf32_<S>hdr.sh_entsize) (record-length #+64-bit-target :<E>lf64_<S>ym
414                                                                           #+32-bit-target :<E>lf32_<S>ym)
415          (pref symbols-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_link
416                #+32-bit-target :<E>lf32_<S>hdr.sh_link) (elf-section-index strings-section))
417    (setf (pref strings-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_name
418                #+32-bit-target :<E>lf32_<S>hdr.sh_name) (elf-register-string ".strtab" section-names)
419          (pref strings-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_type
420                #+32-bit-target :<E>lf32_<S>hdr.sh_type) #$SHT_STRTAB
421          (pref strings-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_flags
422                #+32-bit-target :<E>lf32_<S>hdr.sh_flags) (logior #$SHF_STRINGS #$SHF_ALLOC))
423    (setf (pref shstrtab-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_name
424                #+32-bit-target :<E>lf32_<S>hdr.sh_name) (elf-register-string ".shstrtab" section-names)
425          (pref shstrtab-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_type
426                #+32-bit-target :<E>lf32_<S>hdr.sh_type) #$SHT_STRTAB
427          (pref shstrtab-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_flags
428                #+32-bit-target :<E>lf32_<S>hdr.sh_flags) (logior #$SHF_STRINGS #$SHF_ALLOC))
429    ;; The perf profiler recognizes prelinked libraries by the presence of
430    ;; some section with this exact name; it doesn't care about the section's
431    ;; contents or other attributes, currently.
432    ;; We want that profiler to treat the lisp section as if it was prelinked.
433    (setf (pref prelink-id-section-header #+64-bit-target :<E>lf64_<S>hdr.sh_name
434                #+32-bit-target :<E>lf32_<S>hdr.sh_name) (elf-register-string ".gnu.prelink_undo" section-names))
435   
436    (elf-make-empty-data-for-section object lisp-section (ash (- (%fixnum-ref *readonly-area* target::area.active) (%fixnum-ref *readonly-area* target::area.low) )target::fixnumshift))
437    (elf-init-section-data-from-string-table object strings-section (elf-symbol-table-strings symbols))
438    (elf-init-section-data-from-string-table object shstrtab-section section-names)
439    (elf-init-symbol-section-from-symbol-table object symbols-section symbols)
440    (elf-make-empty-data-for-section object prelink-id-section 0)
441    ;; Prepare in-memory data structures.
442    (elf-update object #$ELF_C_NULL)
443    ;; Fix up the program header.
444    (setf (pref program-header
445                #+64-bit-target :<E>lf64_<P>hdr.p_type
446                #+32-bit-target :<E>lf32_<P>hdr.p_type) #$PT_PHDR
447          (pref program-header #+64-bit-target :<E>lf64_<P>hdr.p_offset
448                #+32-bit-target :<E>lf32_<P>hdr.p_offset)
449          (pref file-header
450                #+64-bit-target :<E>lf64_<E>hdr.e_phoff
451                #+32-bit-target :<E>lf32_<E>hdr.e_phoff)
452          (pref program-header
453                #+64-bit-target :<E>lf64_<P>hdr.p_filesz
454                #+32-bit-target :<E>lf32_<P>hdr.p_filesz)
455          (#+64-bit-target #_elf64_fsize #+32-bit-target #_elf32_fsize #$ELF_T_PHDR 1 #$EV_CURRENT))
456    ;; Mark the program header as being dirty.
457    (elf-flag-phdr object #$ELF_C_SET #$ELF_F_DIRTY)
458    (let* ((eof (elf-update object #$ELF_C_WRITE))
459           (fd (elf-object-fd object)))
460      (elf-end object)
461      (fixup-lisp-section-offset fd eof lisp-section-index)
462      (fd-close fd))
463    pathname))
464
465     
466   
467   
Note: See TracBrowser for help on using the repository browser.