Improve compressed dwarf offset handling

Author: jeaye

src/symbols/dwarf/dwarf_resolver.cpp

@@ -23,6 +23,9 @@
 #endif
 #if IS_LINUX
 #include <elf.h>
+#include <stddef.h>
+#include <zlib.h>
+extern "C" size_t ZSTD_decompress(void*, size_t, const void*, size_t);
 #endif
 
 #include <algorithm>
@@ -67,7 +70,61 @@ namespace libdwarf {
         explicit in_memory_dwarf_object(elf::object_data&& object_data_)
             : object_data(std::move(object_data_)),
               relocated_sections(object_data.sections.size(), false),
-              interface{this, &methods} {}
+              interface{this, &methods} {
+            decompress_compressed_sections();
+        }
+
+        // libdwarf decompresses SHF_COMPRESSED sections itself, but only after load_section, and it then
+        // asks us to relocate its decompressed copy, which we can't reach. Relocations would instead land
+        // on the compressed bytes, leaving the DWARF unrelocated. Handing libdwarf plain sections avoids it.
+        void decompress_compressed_sections() {
+            constexpr std::uint64_t shf_compressed = 0x800;
+            for(auto& section : object_data.sections) {
+                if(!(section.flags & shf_compressed) || section.type == SHT_NOBITS) {
+                    continue;
+                }
+                const auto header_size = object_data.is_64_bit ? sizeof(Elf64_Chdr) : sizeof(Elf32_Chdr);
+                if(section.data.size() < header_size) {
+                    continue;
+                }
+                std::uint32_t type = 0;
+                std::uint64_t uncompressed_size = 0;
+                if(object_data.is_64_bit) {
+                    Elf64_Chdr header;
+                    std::memcpy(&header, section.data.data(), sizeof(header));
+                    type = byteswap_if_needed(header.ch_type);
+                    uncompressed_size = byteswap_if_needed(header.ch_size);
+                } else {
+                    Elf32_Chdr header;
+                    std::memcpy(&header, section.data.data(), sizeof(header));
+                    type = byteswap_if_needed(header.ch_type);
+                    uncompressed_size = byteswap_if_needed(header.ch_size);
+                }
+                if(uncompressed_size > (std::uint64_t(1) << 32)) {
+                    continue;
+                }
+                std::vector<char> output(static_cast<std::size_t>(uncompressed_size));
+                const auto* input = reinterpret_cast<const unsigned char*>(section.data.data()) + header_size;
+                const auto input_size = section.data.size() - header_size;
+                bool ok = false;
+                if(type == 1) { // ELFCOMPRESS_ZLIB
+                    uLongf out_size = static_cast<uLongf>(output.size());
+                    ok = ::uncompress(
+                        reinterpret_cast<Bytef*>(output.data()), &out_size, input, static_cast<uLong>(input_size)
+                    ) == Z_OK && out_size == output.size();
+                } else if(type == 2) { // ELFCOMPRESS_ZSTD
+                    const auto result = ZSTD_decompress(output.data(), output.size(), input, input_size);
+                    ok = result == output.size();
+                }
+                if(!ok) {
+                    log::warn("Failed to decompress DWARF section {}", section.name);
+                    continue;
+                }
+                section.data = std::move(output);
+                section.size = section.data.size();
+                section.flags &= ~shf_compressed;
+            }
+        }
 
         template<typename T>
         T byteswap_if_needed(T value) const {