X-Git-Url: http://drtracing.org/?a=blobdiff_plain;ds=sidebyside;f=gold%2Fcompressed_output.cc;h=9abefe1ea8b6406f108ef291cee340a7cdb61ab2;hb=48189beca8aeb629deaf2d92268d6d234ce19aeb;hp=a0f8ed181ace455f9db37188f9fa3a1822561ed4;hpb=2ea97941102380c28117882600265c1187c6fc8b;p=deliverable%2Fbinutils-gdb.git diff --git a/gold/compressed_output.cc b/gold/compressed_output.cc index a0f8ed181a..9abefe1ea8 100644 --- a/gold/compressed_output.cc +++ b/gold/compressed_output.cc @@ -1,6 +1,6 @@ -// compressed_output.cc -- manage compressed output sections for gold +// compressed_output.cc -- manage compressed debug sections for gold -// Copyright 2007, 2008 Free Software Foundation, Inc. +// Copyright (C) 2007-2020 Free Software Foundation, Inc. // Written by Ian Lance Taylor . // This file is part of gold. @@ -21,11 +21,7 @@ // MA 02110-1301, USA. #include "gold.h" - -#ifdef HAVE_ZLIB_H #include -#endif - #include "parameters.h" #include "options.h" #include "compressed_output.h" @@ -42,15 +38,13 @@ namespace gold // "ZLIB", and 8 bytes indicating the uncompressed size, in big-endian // order. -#ifdef HAVE_ZLIB_H - static bool -zlib_compress(const unsigned char* uncompressed_data, +zlib_compress(int header_size, + const unsigned char* uncompressed_data, unsigned long uncompressed_size, unsigned char** compressed_data, unsigned long* compressed_size) { - const int header_size = 12; *compressed_size = uncompressed_size + uncompressed_size / 1000 + 128; *compressed_data = new unsigned char[*compressed_size + header_size]; @@ -67,9 +61,6 @@ zlib_compress(const unsigned char* uncompressed_data, compress_level); if (rc == Z_OK) { - memcpy(*compressed_data, "ZLIB", 4); - elfcpp::Swap_unaligned<64, true>::writeval(*compressed_data + 4, - uncompressed_size); *compressed_size += header_size; return true; } @@ -81,16 +72,142 @@ zlib_compress(const unsigned char* uncompressed_data, } } -#else // !defined(HAVE_ZLIB_H) +// Decompress COMPRESSED_DATA of size COMPRESSED_SIZE, into a buffer +// UNCOMPRESSED_DATA of size UNCOMPRESSED_SIZE. Returns TRUE if it +// decompressed successfully, false if it failed. The buffer, of +// appropriate size, is provided by the caller, and is typically part +// of the memory-mapped output file. static bool -zlib_compress(const unsigned char*, unsigned long, - unsigned char**, unsigned long*) +zlib_decompress(const unsigned char* compressed_data, + unsigned long compressed_size, + unsigned char* uncompressed_data, + unsigned long uncompressed_size) { - return false; + z_stream strm; + int rc; + + /* It is possible the section consists of several compressed + buffers concatenated together, so we uncompress in a loop. */ + strm.zalloc = NULL; + strm.zfree = NULL; + strm.opaque = NULL; + strm.avail_in = compressed_size; + strm.next_in = const_cast(compressed_data); + strm.avail_out = uncompressed_size; + + rc = inflateInit(&strm); + while (strm.avail_in > 0) + { + if (rc != Z_OK) + return false; + strm.next_out = ((Bytef*) uncompressed_data + + (uncompressed_size - strm.avail_out)); + rc = inflate(&strm, Z_FINISH); + if (rc != Z_STREAM_END) + return false; + rc = inflateReset(&strm); + } + rc = inflateEnd(&strm); + if (rc != Z_OK || strm.avail_out != 0) + return false; + + return true; +} + +// Read the compression header of a compressed debug section and return +// the uncompressed size. + +uint64_t +get_uncompressed_size(const unsigned char* compressed_data, + section_size_type compressed_size) +{ + const unsigned int zlib_header_size = 12; + + /* Verify the compression header. Currently, we support only zlib + compression, so it should be "ZLIB" followed by the uncompressed + section size, 8 bytes in big-endian order. */ + if (compressed_size >= zlib_header_size + && strncmp(reinterpret_cast(compressed_data), + "ZLIB", 4) == 0) + return elfcpp::Swap_unaligned<64, true>::readval(compressed_data + 4); + return -1ULL; } -#endif // !defined(HAVE_ZLIB_H) +// Decompress a compressed debug section directly into the output file. + +bool +decompress_input_section(const unsigned char* compressed_data, + unsigned long compressed_size, + unsigned char* uncompressed_data, + unsigned long uncompressed_size, + int size, + bool big_endian, + elfcpp::Elf_Xword sh_flags) +{ + if ((sh_flags & elfcpp::SHF_COMPRESSED) != 0) + { + unsigned int compression_header_size; + if (size == 32) + { + compression_header_size = elfcpp::Elf_sizes<32>::chdr_size; + if (big_endian) + { + elfcpp::Chdr<32, true> chdr(compressed_data); + if (chdr.get_ch_type() != elfcpp::ELFCOMPRESS_ZLIB) + return false; + } + else + { + elfcpp::Chdr<32, false> chdr(compressed_data); + if (chdr.get_ch_type() != elfcpp::ELFCOMPRESS_ZLIB) + return false; + } + } + else if (size == 64) + { + compression_header_size = elfcpp::Elf_sizes<64>::chdr_size; + if (big_endian) + { + elfcpp::Chdr<64, true> chdr(compressed_data); + if (chdr.get_ch_type() != elfcpp::ELFCOMPRESS_ZLIB) + return false; + } + else + { + elfcpp::Chdr<64, false> chdr(compressed_data); + if (chdr.get_ch_type() != elfcpp::ELFCOMPRESS_ZLIB) + return false; + } + } + else + gold_unreachable(); + + return zlib_decompress(compressed_data + compression_header_size, + compressed_size - compression_header_size, + uncompressed_data, + uncompressed_size); + } + + const unsigned int zlib_header_size = 12; + + /* Verify the compression header. Currently, we support only zlib + compression, so it should be "ZLIB" followed by the uncompressed + section size, 8 bytes in big-endian order. */ + if (compressed_size >= zlib_header_size + && strncmp(reinterpret_cast(compressed_data), + "ZLIB", 4) == 0) + { + unsigned long uncompressed_size_check = + elfcpp::Swap_unaligned<64, true>::readval(compressed_data + 4); + gold_assert(uncompressed_size_check == uncompressed_size); + return zlib_decompress(compressed_data + zlib_header_size, + compressed_size - zlib_header_size, + uncompressed_data, + uncompressed_size); + } + return false; +} // Class Output_compressed_section. @@ -113,14 +230,89 @@ Output_compressed_section::set_final_data_size() this->write_to_postprocessing_buffer(); bool success = false; - if (strcmp(this->options_->compress_debug_sections(), "zlib") == 0) - success = zlib_compress(uncompressed_data, uncompressed_size, - &this->data_, &compressed_size); + enum { none, gnu_zlib, gabi_zlib } compress; + int compression_header_size = 12; + const int size = parameters->target().get_size(); + if (strcmp(this->options_->compress_debug_sections(), "zlib-gnu") == 0) + compress = gnu_zlib; + else if (strcmp(this->options_->compress_debug_sections(), "zlib-gabi") == 0 + || strcmp(this->options_->compress_debug_sections(), "zlib") == 0) + { + compress = gabi_zlib; + if (size == 32) + compression_header_size = elfcpp::Elf_sizes<32>::chdr_size; + else if (size == 64) + compression_header_size = elfcpp::Elf_sizes<64>::chdr_size; + else + gold_unreachable(); + } + else + compress = none; + if (compress != none) + success = zlib_compress(compression_header_size, uncompressed_data, + uncompressed_size, &this->data_, + &compressed_size); if (success) { - // This converts .debug_foo to .zdebug_foo - this->new_section_name_ = std::string(".z") + (this->name() + 1); - this->set_name(this->new_section_name_.c_str()); + elfcpp::Elf_Xword flags = this->flags(); + if (compress == gabi_zlib) + { + // Set the SHF_COMPRESSED bit. + flags |= elfcpp::SHF_COMPRESSED; + const bool is_big_endian = parameters->target().is_big_endian(); + uint64_t addralign = this->addralign(); + if (size == 32) + { + if (is_big_endian) + { + elfcpp::Chdr_write<32, true> chdr(this->data_); + chdr.put_ch_type(elfcpp::ELFCOMPRESS_ZLIB); + chdr.put_ch_size(uncompressed_size); + chdr.put_ch_addralign(addralign); + } + else + { + elfcpp::Chdr_write<32, false> chdr(this->data_); + chdr.put_ch_type(elfcpp::ELFCOMPRESS_ZLIB); + chdr.put_ch_size(uncompressed_size); + chdr.put_ch_addralign(addralign); + } + } + else if (size == 64) + { + if (is_big_endian) + { + elfcpp::Chdr_write<64, true> chdr(this->data_); + chdr.put_ch_type(elfcpp::ELFCOMPRESS_ZLIB); + chdr.put_ch_size(uncompressed_size); + chdr.put_ch_addralign(addralign); + // Clear the reserved field. + chdr.put_ch_reserved(0); + } + else + { + elfcpp::Chdr_write<64, false> chdr(this->data_); + chdr.put_ch_type(elfcpp::ELFCOMPRESS_ZLIB); + chdr.put_ch_size(uncompressed_size); + chdr.put_ch_addralign(addralign); + // Clear the reserved field. + chdr.put_ch_reserved(0); + } + } + else + gold_unreachable(); + } + else + { + // Write out the zlib header. + memcpy(this->data_, "ZLIB", 4); + elfcpp::Swap_unaligned<64, true>::writeval(this->data_ + 4, + uncompressed_size); + // This converts .debug_foo to .zdebug_foo + this->new_section_name_ = std::string(".z") + (this->name() + 1); + this->set_name(this->new_section_name_.c_str()); + } + this->set_flags(flags); this->set_data_size(compressed_size); } else