Automatic date update in version.in
[external/binutils.git] / bfd / compress.c
1 /* Compressed section support (intended for debug sections).
2    Copyright (C) 2008-2019 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
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.
10
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.
15
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.  */
20
21 #include "sysdep.h"
22 #include <zlib.h>
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "safe-ctype.h"
26
27 #define MAX_COMPRESSION_HEADER_SIZE 24
28
29 static bfd_boolean
30 decompress_contents (bfd_byte *compressed_buffer,
31                      bfd_size_type compressed_size,
32                      bfd_byte *uncompressed_buffer,
33                      bfd_size_type uncompressed_size)
34 {
35   z_stream strm;
36   int rc;
37
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
44      that we need.  */
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;
49
50   BFD_ASSERT (Z_OK == 0);
51   rc = inflateInit (&strm);
52   while (strm.avail_in > 0 && strm.avail_out > 0)
53     {
54       if (rc != Z_OK)
55         break;
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)
60         break;
61       rc = inflateReset (&strm);
62     }
63   rc |= inflateEnd (&strm);
64   return rc == Z_OK && strm.avail_out == 0;
65 }
66
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.
71
72    Return the uncompressed size if the full section contents is
73    compressed successfully.  Otherwise return 0.  */
74
75 static bfd_size_type
76 bfd_compress_section_contents (bfd *abfd, sec_ptr sec,
77                                bfd_byte *uncompressed_buffer,
78                                bfd_size_type uncompressed_size)
79 {
80   uLong compressed_size;
81   bfd_byte *buffer;
82   bfd_size_type buffer_size;
83   bfd_boolean decompress;
84   int zlib_size = 0;
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);
94
95   /* Either ELF compression header or the 12-byte, "ZLIB" + 8-byte size,
96      overhead in .zdebug* section.  */
97   if (!header_size)
98      header_size = 12;
99
100   if (compressed)
101     {
102       /* We shouldn't decompress unsupported compressed section.  */
103       if (orig_compression_header_size < 0)
104         abort ();
105
106       /* Different compression schemes.  Just move the compressed section
107          contents to the right position. */
108       if (orig_compression_header_size == 0)
109         {
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;
116         }
117       else
118         {
119           /* Convert it to .zdebug* section.  */
120           zlib_size = uncompressed_size - orig_compression_header_size;
121         }
122
123       /* Add the header size.  */
124       compressed_size = zlib_size + header_size;
125     }
126   else
127     compressed_size = compressBound (uncompressed_size) + header_size;
128
129   /* Uncompress if it leads to smaller size.  */
130   if (compressed && compressed_size > orig_uncompressed_size)
131     {
132       decompress = TRUE;
133       buffer_size = orig_uncompressed_size;
134     }
135   else
136     {
137       decompress = FALSE;
138       buffer_size = compressed_size;
139     }
140   buffer = (bfd_byte *) bfd_alloc (abfd, buffer_size);
141   if (buffer == NULL)
142     return 0;
143
144   if (compressed)
145     {
146       sec->size = orig_uncompressed_size;
147       if (decompress)
148         {
149           if (!decompress_contents (uncompressed_buffer
150                                     + orig_compression_header_size,
151                                     zlib_size, buffer, buffer_size))
152             {
153               bfd_set_error (bfd_error_bad_value);
154               bfd_release (abfd, buffer);
155               return 0;
156             }
157           free (uncompressed_buffer);
158           bfd_set_section_alignment (abfd, sec,
159                                      orig_uncompressed_alignment_pow);
160
161           sec->contents = buffer;
162           sec->compress_status = COMPRESS_SECTION_DONE;
163           return orig_uncompressed_size;
164         }
165       else
166         {
167           bfd_update_compression_header (abfd, buffer, sec);
168           memmove (buffer + header_size,
169                    uncompressed_buffer + orig_compression_header_size,
170                    zlib_size);
171         }
172     }
173   else
174     {
175       if (compress ((Bytef*) buffer + header_size,
176                     &compressed_size,
177                     (const Bytef*) uncompressed_buffer,
178                     uncompressed_size) != Z_OK)
179         {
180           bfd_release (abfd, buffer);
181           bfd_set_error (bfd_error_bad_value);
182           return 0;
183         }
184
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);
190       else
191         {
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;
198         }
199     }
200
201   free (uncompressed_buffer);
202   sec->contents = buffer;
203   sec->size = compressed_size;
204   sec->compress_status = COMPRESS_SECTION_DONE;
205
206   return uncompressed_size;
207 }
208
209 /*
210 FUNCTION
211         bfd_get_full_section_contents
212
213 SYNOPSIS
214         bfd_boolean bfd_get_full_section_contents
215           (bfd *abfd, asection *section, bfd_byte **ptr);
216
217 DESCRIPTION
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.
221
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.
225 */
226
227 bfd_boolean
228 bfd_get_full_section_contents (bfd *abfd, sec_ptr sec, bfd_byte **ptr)
229 {
230   bfd_size_type sz;
231   bfd_byte *p = *ptr;
232   bfd_boolean ret;
233   bfd_size_type save_size;
234   bfd_size_type save_rawsize;
235   bfd_byte *compressed_buffer;
236   unsigned int compression_header_size;
237
238   if (abfd->direction != write_direction && sec->rawsize != 0)
239     sz = sec->rawsize;
240   else
241     sz = sec->size;
242   if (sz == 0)
243     {
244       *ptr = NULL;
245       return TRUE;
246     }
247
248   switch (sec->compress_status)
249     {
250     case COMPRESS_SECTION_NONE:
251       if (p == NULL)
252         {
253           p = (bfd_byte *) bfd_malloc (sz);
254           if (p == NULL)
255             {
256               /* PR 20801: Provide a more helpful error message.  */
257               if (bfd_get_error () == bfd_error_no_memory)
258                 _bfd_error_handler
259                   /* xgettext:c-format */
260                   (_("error: %pB(%pA) is too large (%#" PRIx64 " bytes)"),
261                   abfd, sec, (uint64_t) sz);
262               return FALSE;
263             }
264         }
265
266       if (!bfd_get_section_contents (abfd, sec, p, 0, sz))
267         {
268           if (*ptr != p)
269             free (p);
270           return FALSE;
271         }
272       *ptr = p;
273       return TRUE;
274
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)
279         return FALSE;
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.  */
285       sec->rawsize = 0;
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;
294       if (!ret)
295         goto fail_compressed;
296
297       if (p == NULL)
298         p = (bfd_byte *) bfd_malloc (sz);
299       if (p == NULL)
300         goto fail_compressed;
301
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))
309         {
310           bfd_set_error (bfd_error_bad_value);
311           if (p != *ptr)
312             free (p);
313         fail_compressed:
314           free (compressed_buffer);
315           return FALSE;
316         }
317
318       free (compressed_buffer);
319       *ptr = p;
320       return TRUE;
321
322     case COMPRESS_SECTION_DONE:
323       if (sec->contents == NULL)
324         return FALSE;
325       if (p == NULL)
326         {
327           p = (bfd_byte *) bfd_malloc (sz);
328           if (p == NULL)
329             return FALSE;
330           *ptr = p;
331         }
332       /* PR 17512; file: 5bc29788.  */
333       if (p != sec->contents)
334         memcpy (p, sec->contents, sz);
335       return TRUE;
336
337     default:
338       abort ();
339     }
340 }
341
342 /*
343 FUNCTION
344         bfd_cache_section_contents
345
346 SYNOPSIS
347         void bfd_cache_section_contents
348           (asection *sec, void *contents);
349
350 DESCRIPTION
351         Stash @var(contents) so any following reads of @var(sec) do
352         not need to decompress again.
353 */
354
355 void
356 bfd_cache_section_contents (asection *sec, void *contents)
357 {
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;
362 }
363
364 /*
365 FUNCTION
366         bfd_is_section_compressed_with_header
367
368 SYNOPSIS
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);
374
375 DESCRIPTION
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.
383 */
384
385 bfd_boolean
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)
390 {
391   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
392   int compression_header_size;
393   int header_size;
394   unsigned int saved = sec->compress_status;
395   bfd_boolean compressed;
396
397   *uncompressed_align_pow_p = 0;
398
399   compression_header_size = bfd_get_compression_header_size (abfd, sec);
400   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
401     abort ();
402   header_size = compression_header_size ? compression_header_size : 12;
403
404   /* Don't decompress the section.  */
405   sec->compress_status = COMPRESS_SECTION_NONE;
406
407   /* Read the header.  */
408   if (bfd_get_section_contents (abfd, sec, header, 0, header_size))
409     {
410       if (compression_header_size == 0)
411         /* In this case, it should be "ZLIB" followed by the uncompressed
412            section size, 8 bytes in big-endian order.  */
413         compressed = CONST_STRNEQ ((char*) header , "ZLIB");
414       else
415         compressed = TRUE;
416     }
417   else
418     compressed = FALSE;
419
420   *uncompressed_size_p = sec->size;
421   if (compressed)
422     {
423       if (compression_header_size != 0)
424         {
425           if (!bfd_check_compression_header (abfd, header, sec,
426                                              uncompressed_size_p,
427                                              uncompressed_align_pow_p))
428             compression_header_size = -1;
429         }
430       /* Check for the pathalogical case of a debug string section that
431          contains the string ZLIB.... as the first entry.  We assume that
432          no uncompressed .debug_str section would ever be big enough to
433          have the first byte of its (big-endian) size be non-zero.  */
434       else if (strcmp (sec->name, ".debug_str") == 0
435                && ISPRINT (header[4]))
436         compressed = FALSE;
437       else
438         *uncompressed_size_p = bfd_getb64 (header + 4);
439     }
440
441   /* Restore compress_status.  */
442   sec->compress_status = saved;
443   *compression_header_size_p = compression_header_size;
444   return compressed;
445 }
446
447 /*
448 FUNCTION
449         bfd_is_section_compressed
450
451 SYNOPSIS
452         bfd_boolean bfd_is_section_compressed
453           (bfd *abfd, asection *section);
454
455 DESCRIPTION
456         Return @code{TRUE} if @var{section} is compressed.
457 */
458
459 bfd_boolean
460 bfd_is_section_compressed (bfd *abfd, sec_ptr sec)
461 {
462   int compression_header_size;
463   bfd_size_type uncompressed_size;
464   unsigned int uncompressed_align_power;
465   return (bfd_is_section_compressed_with_header (abfd, sec,
466                                                  &compression_header_size,
467                                                  &uncompressed_size,
468                                                  &uncompressed_align_power)
469           && compression_header_size >= 0
470           && uncompressed_size > 0);
471 }
472
473 /*
474 FUNCTION
475         bfd_init_section_decompress_status
476
477 SYNOPSIS
478         bfd_boolean bfd_init_section_decompress_status
479           (bfd *abfd, asection *section);
480
481 DESCRIPTION
482         Record compressed section size, update section size with
483         decompressed size and set compress_status to
484         DECOMPRESS_SECTION_SIZED.
485
486         Return @code{FALSE} if the section is not a valid compressed
487         section.  Otherwise, return @code{TRUE}.
488 */
489
490 bfd_boolean
491 bfd_init_section_decompress_status (bfd *abfd, sec_ptr sec)
492 {
493   bfd_byte header[MAX_COMPRESSION_HEADER_SIZE];
494   int compression_header_size;
495   int header_size;
496   bfd_size_type uncompressed_size;
497   unsigned int uncompressed_alignment_power = 0;
498
499   compression_header_size = bfd_get_compression_header_size (abfd, sec);
500   if (compression_header_size > MAX_COMPRESSION_HEADER_SIZE)
501     abort ();
502   header_size = compression_header_size ? compression_header_size : 12;
503
504   /* Read the header.  */
505   if (sec->rawsize != 0
506       || sec->contents != NULL
507       || sec->compress_status != COMPRESS_SECTION_NONE
508       || !bfd_get_section_contents (abfd, sec, header, 0, header_size))
509     {
510       bfd_set_error (bfd_error_invalid_operation);
511       return FALSE;
512     }
513
514   if (compression_header_size == 0)
515     {
516       /* In this case, it should be "ZLIB" followed by the uncompressed
517          section size, 8 bytes in big-endian order.  */
518       if (! CONST_STRNEQ ((char*) header, "ZLIB"))
519         {
520           bfd_set_error (bfd_error_wrong_format);
521           return FALSE;
522         }
523       uncompressed_size = bfd_getb64 (header + 4);
524     }
525   else if (!bfd_check_compression_header (abfd, header, sec,
526                                           &uncompressed_size,
527                                           &uncompressed_alignment_power))
528     {
529       bfd_set_error (bfd_error_wrong_format);
530       return FALSE;
531     }
532
533   sec->compressed_size = sec->size;
534   sec->size = uncompressed_size;
535   bfd_set_section_alignment (abfd, sec, uncompressed_alignment_power);
536   sec->compress_status = DECOMPRESS_SECTION_SIZED;
537
538   return TRUE;
539 }
540
541 /*
542 FUNCTION
543         bfd_init_section_compress_status
544
545 SYNOPSIS
546         bfd_boolean bfd_init_section_compress_status
547           (bfd *abfd, asection *section);
548
549 DESCRIPTION
550         If open for read, compress section, update section size with
551         compressed size and set compress_status to COMPRESS_SECTION_DONE.
552
553         Return @code{FALSE} if the section is not a valid compressed
554         section.  Otherwise, return @code{TRUE}.
555 */
556
557 bfd_boolean
558 bfd_init_section_compress_status (bfd *abfd, sec_ptr sec)
559 {
560   bfd_size_type uncompressed_size;
561   bfd_byte *uncompressed_buffer;
562
563   /* Error if not opened for read.  */
564   if (abfd->direction != read_direction
565       || sec->size == 0
566       || sec->rawsize != 0
567       || sec->contents != NULL
568       || sec->compress_status != COMPRESS_SECTION_NONE)
569     {
570       bfd_set_error (bfd_error_invalid_operation);
571       return FALSE;
572     }
573
574   /* Read in the full section contents and compress it.  */
575   uncompressed_size = sec->size;
576   uncompressed_buffer = (bfd_byte *) bfd_malloc (uncompressed_size);
577   /* PR 21431 */
578   if (uncompressed_buffer == NULL)
579     return FALSE;
580
581   if (!bfd_get_section_contents (abfd, sec, uncompressed_buffer,
582                                  0, uncompressed_size))
583     return FALSE;
584
585   uncompressed_size = bfd_compress_section_contents (abfd, sec,
586                                                      uncompressed_buffer,
587                                                      uncompressed_size);
588   return uncompressed_size != 0;
589 }
590
591 /*
592 FUNCTION
593         bfd_compress_section
594
595 SYNOPSIS
596         bfd_boolean bfd_compress_section
597           (bfd *abfd, asection *section, bfd_byte *uncompressed_buffer);
598
599 DESCRIPTION
600         If open for write, compress section, update section size with
601         compressed size and set compress_status to COMPRESS_SECTION_DONE.
602
603         Return @code{FALSE} if compression fail.  Otherwise, return
604         @code{TRUE}.
605 */
606
607 bfd_boolean
608 bfd_compress_section (bfd *abfd, sec_ptr sec, bfd_byte *uncompressed_buffer)
609 {
610   bfd_size_type uncompressed_size = sec->size;
611
612   /* Error if not opened for write.  */
613   if (abfd->direction != write_direction
614       || uncompressed_size == 0
615       || uncompressed_buffer == NULL
616       || sec->contents != NULL
617       || sec->compressed_size != 0
618       || sec->compress_status != COMPRESS_SECTION_NONE)
619     {
620       bfd_set_error (bfd_error_invalid_operation);
621       return FALSE;
622     }
623
624   /* Compress it.  */
625   return bfd_compress_section_contents (abfd, sec, uncompressed_buffer,
626                                         uncompressed_size) != 0;
627 }