gdb/minidebug.c

   1 /* Read MiniDebugInfo data from an objfile.
   2
   3    Copyright (C) 2012-2024 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdb_bfd.h"
  22 #include "symfile.h"
  23 #include "objfiles.h"
  24 #include "gdbcore.h"
  25 #include <algorithm>
  26
  27 #ifdef HAVE_LIBLZMA
  28
  29 /* We stash a reference to the .gnu_debugdata BFD on the enclosing
  30    BFD.  */
  31 static const registry<bfd>::key<gdb_bfd_ref_ptr> gnu_debug_key;
  32
  33 #include <lzma.h>
  34
  35 /* Allocator function for LZMA.  */
  36
  37 static void *
  38 alloc_lzma (void *opaque, size_t nmemb, size_t size)
  39 {
  40   return xmalloc (nmemb * size);
  41 }
  42
  43 /* Free function for LZMA.  */
  44
  45 static void
  46 free_lzma (void *opaque, void *ptr)
  47 {
  48   xfree (ptr);
  49 }
  50
  51 /* The allocator object for LZMA.  Note that 'gdb_lzma_allocator'
  52    cannot be const due to the lzma library function prototypes.  */
  53
  54 static lzma_allocator gdb_lzma_allocator = { alloc_lzma, free_lzma, NULL };
  55
  56 /* Custom bfd_openr_iovec implementation to read compressed data from
  57    a section.  This keeps only the last decompressed block in memory
  58    to allow larger data without using to much memory.  */
  59
  60 struct gdb_lzma_stream : public gdb_bfd_iovec_base
  61 {
  62   /* Section of input BFD from which we are decoding data.  */
  63   asection *section = nullptr;
  64
  65   /* lzma library decompression state.  */
  66   lzma_index *index = nullptr;
  67
  68   /* Currently decoded block.  */
  69   bfd_size_type data_start = 0;
  70   bfd_size_type data_end = 0;
  71   gdb::byte_vector data;
  72
  73
  74   ~gdb_lzma_stream ()
  75   {
  76     lzma_index_end (index, &gdb_lzma_allocator);
  77   }
  78
  79   file_ptr read (bfd *abfd, void *buffer, file_ptr nbytes,
  80                  file_ptr offset) override;
  81
  82   int stat (struct bfd *abfd, struct stat *sb) override;
  83 };
  84
  85 /* bfd_openr_iovec implementation helper for
  86    find_separate_debug_file_in_section.  */
  87
  88 static gdb_lzma_stream *
  89 lzma_open (struct bfd *nbfd, asection *section)
  90 {
  91   bfd_size_type size, offset;
  92   lzma_stream_flags options;
  93   gdb_byte footer[LZMA_STREAM_HEADER_SIZE];
  94   lzma_index *index;
  95   uint64_t memlimit = UINT64_MAX;
  96   struct gdb_lzma_stream *lstream;
  97   size_t pos;
  98
  99   size = bfd_section_size (section);
 100   offset = section->filepos + size - LZMA_STREAM_HEADER_SIZE;
 101   if (size < LZMA_STREAM_HEADER_SIZE
 102       || bfd_seek (section->owner, offset, SEEK_SET) != 0
 103       || bfd_read (footer, LZMA_STREAM_HEADER_SIZE, section->owner)
 104          != LZMA_STREAM_HEADER_SIZE
 105       || lzma_stream_footer_decode (&options, footer) != LZMA_OK
 106       || offset < options.backward_size)
 107     {
 108       bfd_set_error (bfd_error_wrong_format);
 109       return NULL;
 110     }
 111
 112   offset -= options.backward_size;
 113   gdb::byte_vector indexdata (options.backward_size);
 114   index = NULL;
 115   pos = 0;
 116   if (bfd_seek (section->owner, offset, SEEK_SET) != 0
 117       || bfd_read (indexdata.data (), options.backward_size, section->owner)
 118          != options.backward_size
 119       || lzma_index_buffer_decode (&index, &memlimit, &gdb_lzma_allocator,
 120                                    indexdata.data (), &pos,
 121                                    options.backward_size)
 122          != LZMA_OK
 123       || lzma_index_size (index) != options.backward_size)
 124     {
 125       bfd_set_error (bfd_error_wrong_format);
 126       return NULL;
 127     }
 128
 129   lstream = new struct gdb_lzma_stream;
 130   lstream->section = section;
 131   lstream->index = index;
 132
 133   return lstream;
 134 }
 135
 136 /* bfd_openr_iovec read implementation for
 137    find_separate_debug_file_in_section.  */
 138
 139 file_ptr
 140 gdb_lzma_stream::read (struct bfd *nbfd, void *buf, file_ptr nbytes,
 141                        file_ptr offset)
 142 {
 143   bfd_size_type chunk_size;
 144   lzma_index_iter iter;
 145   file_ptr block_offset;
 146   lzma_filter filters[LZMA_FILTERS_MAX + 1];
 147   lzma_block block;
 148   size_t compressed_pos, uncompressed_pos;
 149   file_ptr res;
 150
 151   res = 0;
 152   while (nbytes > 0)
 153     {
 154       if (data.empty () || data_start > offset || offset >= data_end)
 155         {
 156           lzma_index_iter_init (&iter, index);
 157           if (lzma_index_iter_locate (&iter, offset))
 158             break;
 159
 160           gdb::byte_vector compressed (iter.block.total_size);
 161           block_offset = section->filepos + iter.block.compressed_file_offset;
 162           if (bfd_seek (section->owner, block_offset, SEEK_SET) != 0
 163               || bfd_read (compressed.data (), iter.block.total_size,
 164                            section->owner) != iter.block.total_size)
 165             break;
 166
 167           gdb::byte_vector uncompressed (iter.block.uncompressed_size);
 168
 169           memset (&block, 0, sizeof (block));
 170           block.filters = filters;
 171           block.header_size = lzma_block_header_size_decode (compressed[0]);
 172           if (lzma_block_header_decode (&block, &gdb_lzma_allocator,
 173                                         compressed.data ())
 174               != LZMA_OK)
 175             break;
 176
 177           compressed_pos = block.header_size;
 178           uncompressed_pos = 0;
 179           if (lzma_block_buffer_decode (&block, &gdb_lzma_allocator,
 180                                         compressed.data (), &compressed_pos,
 181                                         iter.block.total_size,
 182                                         uncompressed.data (),
 183                                         &uncompressed_pos,
 184                                         iter.block.uncompressed_size)
 185               != LZMA_OK)
 186             break;
 187
 188           data = std::move (uncompressed);
 189           data_start = iter.block.uncompressed_file_offset;
 190           data_end = (iter.block.uncompressed_file_offset
 191                       + iter.block.uncompressed_size);
 192         }
 193
 194       chunk_size = std::min (nbytes, (file_ptr) data_end - offset);
 195       memcpy (buf, data.data () + offset - data_start, chunk_size);
 196       buf = (gdb_byte *) buf + chunk_size;
 197       offset += chunk_size;
 198       nbytes -= chunk_size;
 199       res += chunk_size;
 200     }
 201
 202   return res;
 203 }
 204
 205 /* bfd_openr_iovec stat implementation for
 206    find_separate_debug_file_in_section.  */
 207
 208 int
 209 gdb_lzma_stream::stat (struct bfd *abfd, struct stat *sb)
 210 {
 211   memset (sb, 0, sizeof (struct stat));
 212   sb->st_size = lzma_index_uncompressed_size (index);
 213   return 0;
 214 }
 215
 216 #endif /* HAVE_LIBLZMA  */
 217
 218 /* This looks for a xz compressed separate debug info object file embedded
 219    in a section called .gnu_debugdata.  See
 220    http://fedoraproject.org/wiki/Features/MiniDebugInfo
 221    or the "Separate Debug Sections" of the manual for details.
 222    If we find one we create a iovec based bfd that decompresses the
 223    object data on demand.  If we don't find one, return NULL.  */
 224
 225 gdb_bfd_ref_ptr
 226 find_separate_debug_file_in_section (struct objfile *objfile)
 227 {
 228   asection *section;
 229   gdb_bfd_ref_ptr abfd;
 230
 231   if (objfile->obfd == NULL)
 232     return NULL;
 233
 234   section = bfd_get_section_by_name (objfile->obfd.get (), ".gnu_debugdata");
 235   if (section == NULL)
 236     return NULL;
 237
 238 #ifdef HAVE_LIBLZMA
 239   gdb_bfd_ref_ptr *shared = gnu_debug_key.get (objfile->obfd.get ());
 240   if (shared != nullptr)
 241     return *shared;
 242
 243   std::string filename = string_printf (_(".gnu_debugdata for %s"),
 244                                         objfile_name (objfile));
 245
 246   auto open = [&] (bfd *nbfd) -> gdb_lzma_stream *
 247   {
 248     return lzma_open (nbfd, section);
 249   };
 250
 251   abfd = gdb_bfd_openr_iovec (filename.c_str (), gnutarget, open);
 252   if (abfd == NULL)
 253     return NULL;
 254
 255   if (!bfd_check_format (abfd.get (), bfd_object))
 256     {
 257       warning (_("Cannot parse .gnu_debugdata section; not a BFD object"));
 258       return NULL;
 259     }
 260
 261   gnu_debug_key.emplace (objfile->obfd.get (), abfd);
 262
 263 #else
 264   warning (_("Cannot parse .gnu_debugdata section; LZMA support was "
 265              "disabled at compile time"));
 266 #endif /* !HAVE_LIBLZMA */
 267
 268   return abfd;
 269 }