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 } 628