1 /* Compressed section support (intended for debug sections).
2 Copyright (C) 2008-2018 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program 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
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
25 #include "safe-ctype.h"
27 #define MAX_COMPRESSION_HEADER_SIZE 24
30 decompress_contents (bfd_byte
*compressed_buffer
,
31 bfd_size_type compressed_size
,
32 bfd_byte
*uncompressed_buffer
,
33 bfd_size_type uncompressed_size
)
38 /* It is possible the section consists of several compressed
39 buffers concatenated together, so we uncompress in a loop. */
40 /* PR 18313: The state field in the z_stream structure is supposed
41 to be invisible to the user (ie us), but some compilers will
42 still complain about it being used without initialisation. So
43 we first zero the entire z_stream structure and then set the fields
45 memset (& strm
, 0, sizeof strm
);
46 strm
.avail_in
= compressed_size
;
47 strm
.next_in
= (Bytef
*) compressed_buffer
;
48 strm
.avail_out
= uncompressed_size
;
50 BFD_ASSERT (Z_OK
== 0);
51 rc
= inflateInit (&strm
);
52 while (strm
.avail_in
> 0 && strm
.avail_out
> 0)
56 strm
.next_out
= ((Bytef
*) uncompressed_buffer
57 + (uncompressed_size
- strm
.avail_out
));
58 rc
= inflate (&strm
, Z_FINISH
);
59 if (rc
!= Z_STREAM_END
)
61 rc
= inflateReset (&strm
);
63 rc
|= inflateEnd (&strm
);
64 return rc
== Z_OK
&& strm
.avail_out
== 0;
67 /* Compress data of the size specified in @var{uncompressed_size}
68 and pointed to by @var{uncompressed_buffer} using zlib and store
69 as the contents field. This function assumes the contents
70 field was allocated using bfd_malloc() or equivalent.
72 Return the uncompressed size if the full section contents is
73 compressed successfully. Otherwise return 0. */
76 bfd_compress_section_contents (bfd
*abfd
, sec_ptr sec
,
77 bfd_byte
*uncompressed_buffer
,
78 bfd_size_type uncompressed_size
)
80 uLong compressed_size
;
82 bfd_size_type buffer_size
;
83 bfd_boolean decompress
;
85 int orig_compression_header_size
;
86 bfd_size_type orig_uncompressed_size
;
87 unsigned int orig_uncompressed_alignment_pow
;
88 int header_size
= bfd_get_compression_header_size (abfd
, NULL
);
89 bfd_boolean compressed
90 = bfd_is_section_compressed_with_header (abfd
, sec
,
91 &orig_compression_header_size
,
92 &orig_uncompressed_size
,
93 &orig_uncompressed_alignment_pow
);
95 /* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size,
96 overhead in .zdebug* section. */
102 /* We shouldn't decompress unsupported compressed section. */
103 if (orig_compression_header_size
< 0)
106 /* Different compression schemes. Just move the compressed section
107 contents to the right position. */
108 if (orig_compression_header_size
== 0)
110 /* Convert it from .zdebug* section. Get the uncompressed
111 size first. We need to subtract the 12-byte overhead in
112 .zdebug* section. Set orig_compression_header_size to
113 the 12-bye overhead. */
114 orig_compression_header_size
= 12;
115 zlib_size
= uncompressed_size
- 12;
119 /* Convert it to .zdebug* section. */
120 zlib_size
= uncompressed_size
- orig_compression_header_size
;
123 /* Add the header size. */
124 compressed_size
= zlib_size
+ header_size
;
127 compressed_size
= compressBound (uncompressed_size
) + header_size
;
129 /* Uncompress if it leads to smaller size. */
130 if (compressed
&& compressed_size
> orig_uncompressed_size
)
133 buffer_size
= orig_uncompressed_size
;
138 buffer_size
= compressed_size
;
140 buffer
= (bfd_byte
*) bfd_alloc (abfd
, buffer_size
);
146 sec
->size
= orig_uncompressed_size
;
149 if (!decompress_contents (uncompressed_buffer
150 + orig_compression_header_size
,
151 zlib_size
, buffer
, buffer_size
))
153 bfd_set_error (bfd_error_bad_value
);
154 bfd_release (abfd
, buffer
);
157 free (uncompressed_buffer
);
158 bfd_set_section_alignment (abfd
, sec
,
159 orig_uncompressed_alignment_pow
);
161 sec
->contents
= buffer
;
162 sec
->compress_status
= COMPRESS_SECTION_DONE
;
163 return orig_uncompressed_size
;
167 bfd_update_compression_header (abfd
, buffer
, sec
);
168 memmove (buffer
+ header_size
,
169 uncompressed_buffer
+ orig_compression_header_size
,
175 if (compress ((Bytef
*) buffer
+ header_size
,
177 (const Bytef
*) uncompressed_buffer
,
178 uncompressed_size
) != Z_OK
)
180 bfd_release (abfd
, buffer
);
181 bfd_set_error (bfd_error_bad_value
);
185 compressed_size
+= header_size
;
186 /* PR binutils/18087: If compression didn't make the section smaller,
187 just keep it uncompressed. */
188 if (compressed_size
< uncompressed_size
)
189 bfd_update_compression_header (abfd
, buffer
, sec
);
192 /* NOTE: There is a small memory leak here since
193 uncompressed_buffer is malloced and won't be freed. */
194 bfd_release (abfd
, buffer
);
195 sec
->contents
= uncompressed_buffer
;
196 sec
->compress_status
= COMPRESS_SECTION_NONE
;
197 return uncompressed_size
;
201 free (uncompressed_buffer
);
202 sec
->contents
= buffer
;
203 sec
->size
= compressed_size
;
204 sec
->compress_status
= COMPRESS_SECTION_DONE
;
206 return uncompressed_size
;
211 bfd_get_full_section_contents
214 bfd_boolean bfd_get_full_section_contents
215 (bfd *abfd, asection *section, bfd_byte **ptr);
218 Read all data from @var{section} in BFD @var{abfd}, decompress
219 if needed, and store in @var{*ptr}. If @var{*ptr} is NULL,
220 return @var{*ptr} with memory malloc'd by this function.
222 Return @code{TRUE} if the full section contents is retrieved
223 successfully. If the section has no contents then this function
224 returns @code{TRUE} but @var{*ptr} is set to NULL.
228 bfd_get_full_section_contents (bfd
*abfd
, sec_ptr sec
, bfd_byte
**ptr
)
233 bfd_size_type save_size
;
234 bfd_size_type save_rawsize
;
235 bfd_byte
*compressed_buffer
;
236 unsigned int compression_header_size
;
238 if (abfd
->direction
!= write_direction
&& sec
->rawsize
!= 0)
248 switch (sec
->compress_status
)
250 case COMPRESS_SECTION_NONE
:
253 p
= (bfd_byte
*) bfd_malloc (sz
);
256 /* PR 20801: Provide a more helpful error message. */
257 if (bfd_get_error () == bfd_error_no_memory
)
259 /* xgettext:c-format */
260 (_("error: %pB(%pA) is too large (%#" PRIx64
" bytes)"),
261 abfd
, sec
, (uint64_t) sz
);
266 if (!bfd_get_section_contents (abfd
, sec
, p
, 0, sz
))
275 case DECOMPRESS_SECTION_SIZED
:
276 /* Read in the full compressed section contents. */
277 compressed_buffer
= (bfd_byte
*) bfd_malloc (sec
->compressed_size
);
278 if (compressed_buffer
== NULL
)
280 save_rawsize
= sec
->rawsize
;
281 save_size
= sec
->size
;
282 /* Clear rawsize, set size to compressed size and set compress_status
283 to COMPRESS_SECTION_NONE. If the compressed size is bigger than
284 the uncompressed size, bfd_get_section_contents will fail. */
286 sec
->size
= sec
->compressed_size
;
287 sec
->compress_status
= COMPRESS_SECTION_NONE
;
288 ret
= bfd_get_section_contents (abfd
, sec
, compressed_buffer
,
289 0, sec
->compressed_size
);
290 /* Restore rawsize and size. */
291 sec
->rawsize
= save_rawsize
;
292 sec
->size
= save_size
;
293 sec
->compress_status
= DECOMPRESS_SECTION_SIZED
;
295 goto fail_compressed
;
298 p
= (bfd_byte
*) bfd_malloc (sz
);
300 goto fail_compressed
;
302 compression_header_size
= bfd_get_compression_header_size (abfd
, sec
);
303 if (compression_header_size
== 0)
304 /* Set header size to the zlib header size if it is a
305 SHF_COMPRESSED section. */
306 compression_header_size
= 12;
307 if (!decompress_contents (compressed_buffer
+ compression_header_size
,
308 sec
->compressed_size
- compression_header_size
, p
, sz
))
310 bfd_set_error (bfd_error_bad_value
);
314 free (compressed_buffer
);
318 free (compressed_buffer
);
322 case COMPRESS_SECTION_DONE
:
323 if (sec
->contents
== NULL
)
327 p
= (bfd_byte
*) bfd_malloc (sz
);
332 /* PR 17512; file: 5bc29788. */
333 if (p
!= sec
->contents
)
334 memcpy (p
, sec
->contents
, sz
);
344 bfd_cache_section_contents
347 void bfd_cache_section_contents
348 (asection *sec, void *contents);
351 Stash @var(contents) so any following reads of @var(sec) do
352 not need to decompress again.
356 bfd_cache_section_contents (asection
*sec
, void *contents
)
358 if (sec
->compress_status
== DECOMPRESS_SECTION_SIZED
)
359 sec
->compress_status
= COMPRESS_SECTION_DONE
;
360 sec
->contents
= contents
;
361 sec
->flags
|= SEC_IN_MEMORY
;
366 bfd_is_section_compressed_with_header
369 bfd_boolean bfd_is_section_compressed_with_header
370 (bfd *abfd, asection *section,
371 int *compression_header_size_p,
372 bfd_size_type *uncompressed_size_p,
373 unsigned int *uncompressed_alignment_power_p);
376 Return @code{TRUE} if @var{section} is compressed. Compression
377 header size is returned in @var{compression_header_size_p},
378 uncompressed size is returned in @var{uncompressed_size_p}
379 and the uncompressed data alignement power is returned in
380 @var{uncompressed_align_pow_p}. If compression is
381 unsupported, compression header size is returned with -1
382 and uncompressed size is returned with 0.
386 bfd_is_section_compressed_with_header (bfd
*abfd
, sec_ptr sec
,
387 int *compression_header_size_p
,
388 bfd_size_type
*uncompressed_size_p
,
389 unsigned int *uncompressed_align_pow_p
)
391 bfd_byte header
[MAX_COMPRESSION_HEADER_SIZE
];
392 int compression_header_size
;
394 unsigned int saved
= sec
->compress_status
;
395 bfd_boolean compressed
;
397 compression_header_size
= bfd_get_compression_header_size (abfd
, sec
);
398 if (compression_header_size
> MAX_COMPRESSION_HEADER_SIZE
)
400 header_size
= compression_header_size
? compression_header_size
: 12;
402 /* Don't decompress the section. */
403 sec
->compress_status
= COMPRESS_SECTION_NONE
;
405 /* Read the header. */
406 if (bfd_get_section_contents (abfd
, sec
, header
, 0, header_size
))
408 if (compression_header_size
== 0)
409 /* In this case, it should be "ZLIB" followed by the uncompressed
410 section size, 8 bytes in big-endian order. */
411 compressed
= CONST_STRNEQ ((char*) header
, "ZLIB");
418 *uncompressed_size_p
= sec
->size
;
421 if (compression_header_size
!= 0)
423 if (!bfd_check_compression_header (abfd
, header
, sec
,
425 uncompressed_align_pow_p
))
426 compression_header_size
= -1;
428 /* Check for the pathalogical case of a debug string section that
429 contains the string ZLIB.... as the first entry. We assume that
430 no uncompressed .debug_str section would ever be big enough to
431 have the first byte of its (big-endian) size be non-zero. */
432 else if (strcmp (sec
->name
, ".debug_str") == 0
433 && ISPRINT (header
[4]))
436 *uncompressed_size_p
= bfd_getb64 (header
+ 4);
439 /* Restore compress_status. */
440 sec
->compress_status
= saved
;
441 *compression_header_size_p
= compression_header_size
;
447 bfd_is_section_compressed
450 bfd_boolean bfd_is_section_compressed
451 (bfd *abfd, asection *section);
454 Return @code{TRUE} if @var{section} is compressed.
458 bfd_is_section_compressed (bfd
*abfd
, sec_ptr sec
)
460 int compression_header_size
;
461 bfd_size_type uncompressed_size
;
462 unsigned int uncompressed_align_power
;
463 return (bfd_is_section_compressed_with_header (abfd
, sec
,
464 &compression_header_size
,
466 &uncompressed_align_power
)
467 && compression_header_size
>= 0
468 && uncompressed_size
> 0);
473 bfd_init_section_decompress_status
476 bfd_boolean bfd_init_section_decompress_status
477 (bfd *abfd, asection *section);
480 Record compressed section size, update section size with
481 decompressed size and set compress_status to
482 DECOMPRESS_SECTION_SIZED.
484 Return @code{FALSE} if the section is not a valid compressed
485 section. Otherwise, return @code{TRUE}.
489 bfd_init_section_decompress_status (bfd
*abfd
, sec_ptr sec
)
491 bfd_byte header
[MAX_COMPRESSION_HEADER_SIZE
];
492 int compression_header_size
;
494 bfd_size_type uncompressed_size
;
495 unsigned int uncompressed_alignment_power
= 0;
497 compression_header_size
= bfd_get_compression_header_size (abfd
, sec
);
498 if (compression_header_size
> MAX_COMPRESSION_HEADER_SIZE
)
500 header_size
= compression_header_size
? compression_header_size
: 12;
502 /* Read the header. */
503 if (sec
->rawsize
!= 0
504 || sec
->contents
!= NULL
505 || sec
->compress_status
!= COMPRESS_SECTION_NONE
506 || !bfd_get_section_contents (abfd
, sec
, header
, 0, header_size
))
508 bfd_set_error (bfd_error_invalid_operation
);
512 if (compression_header_size
== 0)
514 /* In this case, it should be "ZLIB" followed by the uncompressed
515 section size, 8 bytes in big-endian order. */
516 if (! CONST_STRNEQ ((char*) header
, "ZLIB"))
518 bfd_set_error (bfd_error_wrong_format
);
521 uncompressed_size
= bfd_getb64 (header
+ 4);
523 else if (!bfd_check_compression_header (abfd
, header
, sec
,
525 &uncompressed_alignment_power
))
527 bfd_set_error (bfd_error_wrong_format
);
531 sec
->compressed_size
= sec
->size
;
532 sec
->size
= uncompressed_size
;
533 bfd_set_section_alignment (abfd
, sec
, uncompressed_alignment_power
);
534 sec
->compress_status
= DECOMPRESS_SECTION_SIZED
;
541 bfd_init_section_compress_status
544 bfd_boolean bfd_init_section_compress_status
545 (bfd *abfd, asection *section);
548 If open for read, compress section, update section size with
549 compressed size and set compress_status to COMPRESS_SECTION_DONE.
551 Return @code{FALSE} if the section is not a valid compressed
552 section. Otherwise, return @code{TRUE}.
556 bfd_init_section_compress_status (bfd
*abfd
, sec_ptr sec
)
558 bfd_size_type uncompressed_size
;
559 bfd_byte
*uncompressed_buffer
;
561 /* Error if not opened for read. */
562 if (abfd
->direction
!= read_direction
565 || sec
->contents
!= NULL
566 || sec
->compress_status
!= COMPRESS_SECTION_NONE
)
568 bfd_set_error (bfd_error_invalid_operation
);
572 /* Read in the full section contents and compress it. */
573 uncompressed_size
= sec
->size
;
574 uncompressed_buffer
= (bfd_byte
*) bfd_malloc (uncompressed_size
);
576 if (uncompressed_buffer
== NULL
)
579 if (!bfd_get_section_contents (abfd
, sec
, uncompressed_buffer
,
580 0, uncompressed_size
))
583 uncompressed_size
= bfd_compress_section_contents (abfd
, sec
,
586 return uncompressed_size
!= 0;
594 bfd_boolean bfd_compress_section
595 (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer);
598 If open for write, compress section, update section size with
599 compressed size and set compress_status to COMPRESS_SECTION_DONE.
601 Return @code{FALSE} if compression fail. Otherwise, return
606 bfd_compress_section (bfd
*abfd
, sec_ptr sec
, bfd_byte
*uncompressed_buffer
)
608 bfd_size_type uncompressed_size
= sec
->size
;
610 /* Error if not opened for write. */
611 if (abfd
->direction
!= write_direction
612 || uncompressed_size
== 0
613 || uncompressed_buffer
== NULL
614 || sec
->contents
!= NULL
615 || sec
->compressed_size
!= 0
616 || sec
->compress_status
!= COMPRESS_SECTION_NONE
)
618 bfd_set_error (bfd_error_invalid_operation
);
623 return bfd_compress_section_contents (abfd
, sec
, uncompressed_buffer
,
624 uncompressed_size
) != 0;