GDB (xrefs)
/tmp/gdb-7.10/gdb/minidebug.c
Go to the documentation of this file.
1 /* Read MiniDebugInfo data from an objfile.
2 
3  Copyright (C) 2012-2015 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 
26 #ifdef HAVE_LIBLZMA
27 
28 #include <lzma.h>
29 
30 /* Allocator function for LZMA. */
31 
32 static void *
33 alloc_lzma (void *opaque, size_t nmemb, size_t size)
34 {
35  return xmalloc (nmemb * size);
36 }
37 
38 /* Free function for LZMA. */
39 
40 static void
41 free_lzma (void *opaque, void *ptr)
42 {
43  xfree (ptr);
44 }
45 
46 /* The allocator object for LZMA. Note that 'gdb_lzma_allocator'
47  cannot be const due to the lzma library function prototypes. */
48 
49 static lzma_allocator gdb_lzma_allocator = { alloc_lzma, free_lzma, NULL };
50 
51 /* Custom bfd_openr_iovec implementation to read compressed data from
52  a section. This keeps only the last decompressed block in memory
53  to allow larger data without using to much memory. */
54 
56 {
57  /* Section of input BFD from which we are decoding data. */
58  asection *section;
59 
60  /* lzma library decompression state. */
61  lzma_index *index;
62 
63  /* Currently decoded block. */
64  bfd_size_type data_start;
65  bfd_size_type data_end;
67 };
68 
69 /* bfd_openr_iovec OPEN_P implementation for
70  find_separate_debug_file_in_section. OPEN_CLOSURE is 'asection *'
71  of the section to decompress.
72 
73  Return 'struct gdb_lzma_stream *' must be freed by caller by xfree,
74  together with its INDEX lzma data. */
75 
76 static void *
77 lzma_open (struct bfd *nbfd, void *open_closure)
78 {
79  asection *section = open_closure;
80  bfd_size_type size, offset;
81  lzma_stream_flags options;
82  gdb_byte footer[LZMA_STREAM_HEADER_SIZE];
83  gdb_byte *indexdata;
84  lzma_index *index;
85  int ret;
86  uint64_t memlimit = UINT64_MAX;
87  struct gdb_lzma_stream *lstream;
88  size_t pos;
89 
90  size = bfd_get_section_size (section);
91  offset = section->filepos + size - LZMA_STREAM_HEADER_SIZE;
92  if (size < LZMA_STREAM_HEADER_SIZE
93  || bfd_seek (section->owner, offset, SEEK_SET) != 0
94  || bfd_bread (footer, LZMA_STREAM_HEADER_SIZE, section->owner)
95  != LZMA_STREAM_HEADER_SIZE
96  || lzma_stream_footer_decode (&options, footer) != LZMA_OK
97  || offset < options.backward_size)
98  {
99  bfd_set_error (bfd_error_wrong_format);
100  return NULL;
101  }
102 
103  offset -= options.backward_size;
104  indexdata = xmalloc (options.backward_size);
105  index = NULL;
106  pos = 0;
107  if (bfd_seek (section->owner, offset, SEEK_SET) != 0
108  || bfd_bread (indexdata, options.backward_size, section->owner)
109  != options.backward_size
110  || lzma_index_buffer_decode (&index, &memlimit, &gdb_lzma_allocator,
111  indexdata, &pos, options.backward_size)
112  != LZMA_OK
113  || lzma_index_size (index) != options.backward_size)
114  {
115  xfree (indexdata);
116  bfd_set_error (bfd_error_wrong_format);
117  return NULL;
118  }
119  xfree (indexdata);
120 
121  lstream = xzalloc (sizeof (struct gdb_lzma_stream));
122  lstream->section = section;
123  lstream->index = index;
124 
125  return lstream;
126 }
127 
128 /* bfd_openr_iovec PREAD_P implementation for
129  find_separate_debug_file_in_section. Passed STREAM
130  is 'struct gdb_lzma_stream *'. */
131 
132 static file_ptr
133 lzma_pread (struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes,
134  file_ptr offset)
135 {
136  struct gdb_lzma_stream *lstream = stream;
137  bfd_size_type chunk_size;
138  lzma_index_iter iter;
139  gdb_byte *compressed, *uncompressed;
140  file_ptr block_offset;
141  lzma_filter filters[LZMA_FILTERS_MAX + 1];
142  lzma_block block;
143  size_t compressed_pos, uncompressed_pos;
144  file_ptr res;
145 
146  res = 0;
147  while (nbytes > 0)
148  {
149  if (lstream->data == NULL
150  || lstream->data_start > offset || offset >= lstream->data_end)
151  {
152  asection *section = lstream->section;
153 
154  lzma_index_iter_init (&iter, lstream->index);
155  if (lzma_index_iter_locate (&iter, offset))
156  break;
157 
158  compressed = xmalloc (iter.block.total_size);
159  block_offset = section->filepos + iter.block.compressed_file_offset;
160  if (bfd_seek (section->owner, block_offset, SEEK_SET) != 0
161  || bfd_bread (compressed, iter.block.total_size, section->owner)
162  != iter.block.total_size)
163  {
164  xfree (compressed);
165  break;
166  }
167 
168  uncompressed = xmalloc (iter.block.uncompressed_size);
169 
170  memset (&block, 0, sizeof (block));
171  block.filters = filters;
172  block.header_size = lzma_block_header_size_decode (compressed[0]);
173  if (lzma_block_header_decode (&block, &gdb_lzma_allocator, compressed)
174  != LZMA_OK)
175  {
176  xfree (compressed);
177  xfree (uncompressed);
178  break;
179  }
180 
181  compressed_pos = block.header_size;
182  uncompressed_pos = 0;
183  if (lzma_block_buffer_decode (&block, &gdb_lzma_allocator,
184  compressed, &compressed_pos,
185  iter.block.total_size,
186  uncompressed, &uncompressed_pos,
187  iter.block.uncompressed_size)
188  != LZMA_OK)
189  {
190  xfree (compressed);
191  xfree (uncompressed);
192  break;
193  }
194 
195  xfree (compressed);
196 
197  xfree (lstream->data);
198  lstream->data = uncompressed;
199  lstream->data_start = iter.block.uncompressed_file_offset;
200  lstream->data_end = (iter.block.uncompressed_file_offset
201  + iter.block.uncompressed_size);
202  }
203 
204  chunk_size = min (nbytes, lstream->data_end - offset);
205  memcpy (buf, lstream->data + offset - lstream->data_start, chunk_size);
206  buf = (gdb_byte *) buf + chunk_size;
207  offset += chunk_size;
208  nbytes -= chunk_size;
209  res += chunk_size;
210  }
211 
212  return res;
213 }
214 
215 /* bfd_openr_iovec CLOSE_P implementation for
216  find_separate_debug_file_in_section. Passed STREAM
217  is 'struct gdb_lzma_stream *'. */
218 
219 static int
220 lzma_close (struct bfd *nbfd,
221  void *stream)
222 {
223  struct gdb_lzma_stream *lstream = stream;
224 
225  lzma_index_end (lstream->index, &gdb_lzma_allocator);
226  xfree (lstream->data);
227  xfree (lstream);
228 
229  /* Zero means success. */
230  return 0;
231 }
232 
233 /* bfd_openr_iovec STAT_P implementation for
234  find_separate_debug_file_in_section. Passed STREAM
235  is 'struct gdb_lzma_stream *'. */
236 
237 static int
238 lzma_stat (struct bfd *abfd,
239  void *stream,
240  struct stat *sb)
241 {
242  struct gdb_lzma_stream *lstream = stream;
243 
244  memset (sb, 0, sizeof (struct stat));
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 *
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
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 }
static file_ptr lzma_pread(struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset)
Definition: minidebug.c:133
bfd * obfd
Definition: objfiles.h:313
void xfree(void *)
Definition: common-utils.c:97
static lzma_allocator gdb_lzma_allocator
Definition: minidebug.c:49
void warning(const char *fmt,...)
Definition: errors.c:26
static void * alloc_lzma(void *opaque, size_t nmemb, size_t size)
Definition: minidebug.c:33
bfd_size_type data_end
Definition: minidebug.c:65
#define _(String)
Definition: gdb_locale.h:40
bfd_size_type data_start
Definition: minidebug.c:64
static int lzma_stat(struct bfd *abfd, void *stream, struct stat *sb)
Definition: minidebug.c:238
gdb_byte * data
Definition: minidebug.c:66
lzma_index * index
Definition: minidebug.c:61
bfd * find_separate_debug_file_in_section(struct objfile *objfile)
Definition: minidebug.c:259
static void * lzma_open(struct bfd *nbfd, void *open_closure)
Definition: minidebug.c:77
char * gnutarget
Definition: corefile.c:437
void gdb_bfd_unref(struct bfd *abfd)
Definition: gdb_bfd.c:475
void * xzalloc(size_t size)
Definition: common-utils.c:91
static int lzma_close(struct bfd *nbfd, void *stream)
Definition: minidebug.c:220
bfd * gdb_bfd_openr_iovec(const char *filename, const char *target, void *(*open_func)(struct bfd *nbfd, void *open_closure), void *open_closure, file_ptr(*pread_func)(struct bfd *nbfd, void *stream, void *buf, file_ptr nbytes, file_ptr offset), int(*close_func)(struct bfd *nbfd, void *stream), int(*stat_func)(struct bfd *abfd, void *stream, struct stat *sb))
Definition: gdb_bfd.c:715
#define min(a, b)
Definition: defs.h:106
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
void * xmalloc(YYSIZE_T)
Definition: block.h:60
bfd_byte gdb_byte
Definition: common-types.h:38
#define SEEK_SET
Definition: defs.h:87
int offset
Definition: agent.c:65
static void free_lzma(void *opaque, void *ptr)
Definition: minidebug.c:41
asection * section
Definition: minidebug.c:58
size_t size
Definition: go32-nat.c:242