OLD | NEW |
(Empty) | |
| 1 /* Read MiniDebugInfo data from an objfile. |
| 2 |
| 3 Copyright (C) 2012-2013 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 <string.h> |
| 23 #include "symfile.h" |
| 24 #include "objfiles.h" |
| 25 #include "gdbcore.h" |
| 26 |
| 27 #ifdef HAVE_LIBLZMA |
| 28 |
| 29 #include <lzma.h> |
| 30 |
| 31 /* Allocator function for LZMA. */ |
| 32 |
| 33 static void * |
| 34 alloc_lzma (void *opaque, size_t nmemb, size_t size) |
| 35 { |
| 36 return xmalloc (nmemb * size); |
| 37 } |
| 38 |
| 39 /* Free function for LZMA. */ |
| 40 |
| 41 static void |
| 42 free_lzma (void *opaque, void *ptr) |
| 43 { |
| 44 xfree (ptr); |
| 45 } |
| 46 |
| 47 /* The allocator object for LZMA. Note that 'gdb_lzma_allocator' |
| 48 cannot be const due to the lzma library function prototypes. */ |
| 49 |
| 50 static lzma_allocator gdb_lzma_allocator = { alloc_lzma, free_lzma, NULL }; |
| 51 |
| 52 /* Custom bfd_openr_iovec implementation to read compressed data from |
| 53 a section. This keeps only the last decompressed block in memory |
| 54 to allow larger data without using to much memory. */ |
| 55 |
| 56 struct lzma_stream |
| 57 { |
| 58 /* Section of input BFD from which we are decoding data. */ |
| 59 asection *section; |
| 60 |
| 61 /* lzma library decompression state. */ |
| 62 lzma_index *index; |
| 63 |
| 64 /* Currently decoded block. */ |
| 65 bfd_size_type data_start; |
| 66 bfd_size_type data_end; |
| 67 gdb_byte *data; |
| 68 }; |
| 69 |
| 70 /* bfd_openr_iovec OPEN_P implementation for |
| 71 find_separate_debug_file_in_section. OPEN_CLOSURE is 'asection *' |
| 72 of the section to decompress. |
| 73 |
| 74 Return 'struct lzma_stream *' must be freed by caller by xfree, together |
| 75 with its INDEX lzma data. */ |
| 76 |
| 77 static void * |
| 78 lzma_open (struct bfd *nbfd, void *open_closure) |
| 79 { |
| 80 asection *section = open_closure; |
| 81 bfd_size_type size, offset; |
| 82 lzma_stream_flags options; |
| 83 gdb_byte footer[LZMA_STREAM_HEADER_SIZE]; |
| 84 gdb_byte *indexdata; |
| 85 lzma_index *index; |
| 86 int ret; |
| 87 uint64_t memlimit = UINT64_MAX; |
| 88 struct lzma_stream *lstream; |
| 89 size_t pos; |
| 90 |
| 91 size = bfd_get_section_size (section); |
| 92 offset = section->filepos + size - LZMA_STREAM_HEADER_SIZE; |
| 93 if (size < LZMA_STREAM_HEADER_SIZE |
| 94 || bfd_seek (section->owner, offset, SEEK_SET) != 0 |
| 95 || bfd_bread (footer, LZMA_STREAM_HEADER_SIZE, section->owner) |
| 96 != LZMA_STREAM_HEADER_SIZE |
| 97 || lzma_stream_footer_decode (&options, footer) != LZMA_OK |
| 98 || offset < options.backward_size) |
| 99 { |
| 100 bfd_set_error (bfd_error_wrong_format); |
| 101 return NULL; |
| 102 } |
| 103 |
| 104 offset -= options.backward_size; |
| 105 indexdata = xmalloc (options.backward_size); |
| 106 index = NULL; |
| 107 pos = 0; |
| 108 if (bfd_seek (section->owner, offset, SEEK_SET) != 0 |
| 109 || bfd_bread (indexdata, options.backward_size, section->owner) |
| 110 != options.backward_size |
| 111 || lzma_index_buffer_decode (&index, &memlimit, &gdb_lzma_allocator, |
| 112 indexdata, &pos, options.backward_size) |
| 113 != LZMA_OK |
| 114 || lzma_index_size (index) != options.backward_size) |
| 115 { |
| 116 xfree (indexdata); |
| 117 bfd_set_error (bfd_error_wrong_format); |
| 118 return NULL; |
| 119 } |
| 120 xfree (indexdata); |
| 121 |
| 122 lstream = xzalloc (sizeof (struct lzma_stream)); |
| 123 lstream->section = section; |
| 124 lstream->index = index; |
| 125 |
| 126 return lstream; |
| 127 } |
| 128 |
| 129 /* bfd_openr_iovec PREAD_P implementation for |
| 130 find_separate_debug_file_in_section. Passed STREAM |
| 131 is 'struct lzma_stream *'. */ |
| 132 |
| 133 static file_ptr |
| 134 lzma_pread (struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, |
| 135 file_ptr offset) |
| 136 { |
| 137 struct lzma_stream *lstream = stream; |
| 138 bfd_size_type chunk_size; |
| 139 lzma_index_iter iter; |
| 140 gdb_byte *compressed, *uncompressed; |
| 141 file_ptr block_offset; |
| 142 lzma_filter filters[LZMA_FILTERS_MAX + 1]; |
| 143 lzma_block block; |
| 144 size_t compressed_pos, uncompressed_pos; |
| 145 file_ptr res; |
| 146 |
| 147 res = 0; |
| 148 while (nbytes > 0) |
| 149 { |
| 150 if (lstream->data == NULL |
| 151 || lstream->data_start > offset || offset >= lstream->data_end) |
| 152 { |
| 153 asection *section = lstream->section; |
| 154 |
| 155 lzma_index_iter_init (&iter, lstream->index); |
| 156 if (lzma_index_iter_locate (&iter, offset)) |
| 157 break; |
| 158 |
| 159 compressed = xmalloc (iter.block.total_size); |
| 160 block_offset = section->filepos + iter.block.compressed_file_offset; |
| 161 if (bfd_seek (section->owner, block_offset, SEEK_SET) != 0 |
| 162 || bfd_bread (compressed, iter.block.total_size, section->owner) |
| 163 != iter.block.total_size) |
| 164 { |
| 165 xfree (compressed); |
| 166 break; |
| 167 } |
| 168 |
| 169 uncompressed = xmalloc (iter.block.uncompressed_size); |
| 170 |
| 171 memset (&block, 0, sizeof (block)); |
| 172 block.filters = filters; |
| 173 block.header_size = lzma_block_header_size_decode (compressed[0]); |
| 174 if (lzma_block_header_decode (&block, &gdb_lzma_allocator, compressed) |
| 175 != LZMA_OK) |
| 176 { |
| 177 xfree (compressed); |
| 178 xfree (uncompressed); |
| 179 break; |
| 180 } |
| 181 |
| 182 compressed_pos = block.header_size; |
| 183 uncompressed_pos = 0; |
| 184 if (lzma_block_buffer_decode (&block, &gdb_lzma_allocator, |
| 185 compressed, &compressed_pos, |
| 186 iter.block.total_size, |
| 187 uncompressed, &uncompressed_pos, |
| 188 iter.block.uncompressed_size) |
| 189 != LZMA_OK) |
| 190 { |
| 191 xfree (compressed); |
| 192 xfree (uncompressed); |
| 193 break; |
| 194 } |
| 195 |
| 196 xfree (compressed); |
| 197 |
| 198 xfree (lstream->data); |
| 199 lstream->data = uncompressed; |
| 200 lstream->data_start = iter.block.uncompressed_file_offset; |
| 201 lstream->data_end = (iter.block.uncompressed_file_offset |
| 202 + iter.block.uncompressed_size); |
| 203 } |
| 204 |
| 205 chunk_size = min (nbytes, lstream->data_end - offset); |
| 206 memcpy (buf, lstream->data + offset - lstream->data_start, chunk_size); |
| 207 buf = (gdb_byte *) buf + chunk_size; |
| 208 offset += chunk_size; |
| 209 nbytes -= chunk_size; |
| 210 res += chunk_size; |
| 211 } |
| 212 |
| 213 return res; |
| 214 } |
| 215 |
| 216 /* bfd_openr_iovec CLOSE_P implementation for |
| 217 find_separate_debug_file_in_section. Passed STREAM |
| 218 is 'struct lzma_stream *'. */ |
| 219 |
| 220 static int |
| 221 lzma_close (struct bfd *nbfd, |
| 222 void *stream) |
| 223 { |
| 224 struct lzma_stream *lstream = stream; |
| 225 |
| 226 lzma_index_end (lstream->index, &gdb_lzma_allocator); |
| 227 xfree (lstream->data); |
| 228 xfree (lstream); |
| 229 |
| 230 /* Zero means success. */ |
| 231 return 0; |
| 232 } |
| 233 |
| 234 /* bfd_openr_iovec STAT_P implementation for |
| 235 find_separate_debug_file_in_section. Passed STREAM |
| 236 is 'struct lzma_stream *'. */ |
| 237 |
| 238 static int |
| 239 lzma_stat (struct bfd *abfd, |
| 240 void *stream, |
| 241 struct stat *sb) |
| 242 { |
| 243 struct lzma_stream *lstream = stream; |
| 244 |
| 245 sb->st_size = lzma_index_uncompressed_size (lstream->index); |
| 246 return 0; |
| 247 } |
| 248 |
| 249 #endif /* HAVE_LIBLZMA */ |
| 250 |
| 251 /* This looks for a xz compressed separate debug info object file embedded |
| 252 in a section called .gnu_debugdata. See |
| 253 http://fedoraproject.org/wiki/Features/MiniDebugInfo |
| 254 or the "Separate Debug Sections" of the manual for details. |
| 255 If we find one we create a iovec based bfd that decompresses the |
| 256 object data on demand. If we don't find one, return NULL. */ |
| 257 |
| 258 bfd * |
| 259 find_separate_debug_file_in_section (struct objfile *objfile) |
| 260 { |
| 261 asection *section; |
| 262 bfd *abfd; |
| 263 |
| 264 if (objfile->obfd == NULL) |
| 265 return NULL; |
| 266 |
| 267 section = bfd_get_section_by_name (objfile->obfd, ".gnu_debugdata"); |
| 268 if (section == NULL) |
| 269 return NULL; |
| 270 |
| 271 #ifdef HAVE_LIBLZMA |
| 272 abfd = gdb_bfd_openr_iovec (objfile_name (objfile), gnutarget, lzma_open, |
| 273 section, lzma_pread, lzma_close, lzma_stat); |
| 274 if (abfd == NULL) |
| 275 return NULL; |
| 276 |
| 277 if (!bfd_check_format (abfd, bfd_object)) |
| 278 { |
| 279 warning (_("Cannot parse .gnu_debugdata section; not a BFD object")); |
| 280 gdb_bfd_unref (abfd); |
| 281 return NULL; |
| 282 } |
| 283 #else |
| 284 warning (_("Cannot parse .gnu_debugdata section; LZMA support was " |
| 285 "disabled at compile time")); |
| 286 abfd = NULL; |
| 287 #endif /* !HAVE_LIBLZMA */ |
| 288 |
| 289 return abfd; |
| 290 } |
OLD | NEW |