]> Git Repo - binutils.git/blob - gdb/dwarf2/line-header.c
Automatic date update in version.in
[binutils.git] / gdb / dwarf2 / line-header.c
1 /* DWARF 2 debugging format support for GDB.
2
3    Copyright (C) 1994-2022 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 "dwarf2/comp-unit-head.h"
22 #include "dwarf2/leb.h"
23 #include "dwarf2/line-header.h"
24 #include "dwarf2/read.h"
25 #include "complaints.h"
26 #include "filenames.h"
27 #include "gdbsupport/pathstuff.h"
28
29 void
30 line_header::add_include_dir (const char *include_dir)
31 {
32   if (dwarf_line_debug >= 2)
33     {
34       size_t new_size;
35       if (version >= 5)
36         new_size = m_include_dirs.size ();
37       else
38         new_size = m_include_dirs.size () + 1;
39       gdb_printf (gdb_stdlog, "Adding dir %zu: %s\n",
40                   new_size, include_dir);
41     }
42   m_include_dirs.push_back (include_dir);
43 }
44
45 void
46 line_header::add_file_name (const char *name,
47                             dir_index d_index,
48                             unsigned int mod_time,
49                             unsigned int length)
50 {
51   file_name_index index
52     = version >= 5 ? file_names_size (): file_names_size () + 1;
53
54   if (dwarf_line_debug >= 2)
55     gdb_printf (gdb_stdlog, "Adding file %d: %s\n", index, name);
56
57   m_file_names.emplace_back (name, index, d_index, mod_time, length);
58 }
59
60 std::string
61 line_header::file_file_name (const file_entry &fe) const
62 {
63   gdb_assert (is_valid_file_index (fe.index));
64
65   std::string ret = fe.name;
66
67   if (IS_ABSOLUTE_PATH (ret))
68     return ret;
69
70   const char *dir = fe.include_dir (this);
71   if (dir != nullptr)
72     ret = path_join (dir, ret.c_str ());
73
74   if (IS_ABSOLUTE_PATH (ret))
75     return ret;
76
77   if (m_comp_dir != nullptr)
78     ret = path_join (m_comp_dir, ret.c_str ());
79
80   return ret;
81 }
82
83 static void
84 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
85 {
86   complaint (_("statement list doesn't fit in .debug_line section"));
87 }
88
89 /* Cover function for read_initial_length.
90    Returns the length of the object at BUF, and stores the size of the
91    initial length in *BYTES_READ and stores the size that offsets will be in
92    *OFFSET_SIZE.
93    If the initial length size is not equivalent to that specified in
94    CU_HEADER then issue a complaint.
95    This is useful when reading non-comp-unit headers.  */
96
97 static LONGEST
98 read_checked_initial_length_and_offset (bfd *abfd, const gdb_byte *buf,
99                                         const struct comp_unit_head *cu_header,
100                                         unsigned int *bytes_read,
101                                         unsigned int *offset_size)
102 {
103   LONGEST length = read_initial_length (abfd, buf, bytes_read);
104
105   gdb_assert (cu_header->initial_length_size == 4
106               || cu_header->initial_length_size == 8
107               || cu_header->initial_length_size == 12);
108
109   if (cu_header->initial_length_size != *bytes_read)
110     complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
111
112   *offset_size = (*bytes_read == 4) ? 4 : 8;
113   return length;
114 }
115
116 /* Read directory or file name entry format, starting with byte of
117    format count entries, ULEB128 pairs of entry formats, ULEB128 of
118    entries count and the entries themselves in the described entry
119    format.  */
120
121 static void
122 read_formatted_entries (dwarf2_per_objfile *per_objfile, bfd *abfd,
123                         const gdb_byte **bufp, struct line_header *lh,
124                         unsigned int offset_size,
125                         void (*callback) (struct line_header *lh,
126                                           const char *name,
127                                           dir_index d_index,
128                                           unsigned int mod_time,
129                                           unsigned int length))
130 {
131   gdb_byte format_count, formati;
132   ULONGEST data_count, datai;
133   const gdb_byte *buf = *bufp;
134   const gdb_byte *format_header_data;
135   unsigned int bytes_read;
136
137   format_count = read_1_byte (abfd, buf);
138   buf += 1;
139   format_header_data = buf;
140   for (formati = 0; formati < format_count; formati++)
141     {
142       read_unsigned_leb128 (abfd, buf, &bytes_read);
143       buf += bytes_read;
144       read_unsigned_leb128 (abfd, buf, &bytes_read);
145       buf += bytes_read;
146     }
147
148   data_count = read_unsigned_leb128 (abfd, buf, &bytes_read);
149   buf += bytes_read;
150   for (datai = 0; datai < data_count; datai++)
151     {
152       const gdb_byte *format = format_header_data;
153       struct file_entry fe;
154
155       for (formati = 0; formati < format_count; formati++)
156         {
157           ULONGEST content_type = read_unsigned_leb128 (abfd, format, &bytes_read);
158           format += bytes_read;
159
160           ULONGEST form  = read_unsigned_leb128 (abfd, format, &bytes_read);
161           format += bytes_read;
162
163           gdb::optional<const char *> string;
164           gdb::optional<unsigned int> uint;
165
166           switch (form)
167             {
168             case DW_FORM_string:
169               string.emplace (read_direct_string (abfd, buf, &bytes_read));
170               buf += bytes_read;
171               break;
172
173             case DW_FORM_line_strp:
174               {
175                 const char *str
176                   = per_objfile->read_line_string (buf, offset_size);
177                 string.emplace (str);
178                 buf += offset_size;
179               }
180               break;
181
182             case DW_FORM_data1:
183               uint.emplace (read_1_byte (abfd, buf));
184               buf += 1;
185               break;
186
187             case DW_FORM_data2:
188               uint.emplace (read_2_bytes (abfd, buf));
189               buf += 2;
190               break;
191
192             case DW_FORM_data4:
193               uint.emplace (read_4_bytes (abfd, buf));
194               buf += 4;
195               break;
196
197             case DW_FORM_data8:
198               uint.emplace (read_8_bytes (abfd, buf));
199               buf += 8;
200               break;
201
202             case DW_FORM_data16:
203               /*  This is used for MD5, but file_entry does not record MD5s. */
204               buf += 16;
205               break;
206
207             case DW_FORM_udata:
208               uint.emplace (read_unsigned_leb128 (abfd, buf, &bytes_read));
209               buf += bytes_read;
210               break;
211
212             case DW_FORM_block:
213               /* It is valid only for DW_LNCT_timestamp which is ignored by
214                  current GDB.  */
215               break;
216             }
217
218           switch (content_type)
219             {
220             case DW_LNCT_path:
221               if (string.has_value ())
222                 fe.name = *string;
223               break;
224             case DW_LNCT_directory_index:
225               if (uint.has_value ())
226                 fe.d_index = (dir_index) *uint;
227               break;
228             case DW_LNCT_timestamp:
229               if (uint.has_value ())
230                 fe.mod_time = *uint;
231               break;
232             case DW_LNCT_size:
233               if (uint.has_value ())
234                 fe.length = *uint;
235               break;
236             case DW_LNCT_MD5:
237               break;
238             default:
239               complaint (_("Unknown format content type %s"),
240                          pulongest (content_type));
241             }
242         }
243
244       callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
245     }
246
247   *bufp = buf;
248 }
249
250 /* See line-header.h.  */
251
252 line_header_up
253 dwarf_decode_line_header  (sect_offset sect_off, bool is_dwz,
254                            dwarf2_per_objfile *per_objfile,
255                            struct dwarf2_section_info *section,
256                            const struct comp_unit_head *cu_header,
257                            const char *comp_dir)
258 {
259   const gdb_byte *line_ptr;
260   unsigned int bytes_read, offset_size;
261   int i;
262   const char *cur_dir, *cur_file;
263
264   bfd *abfd = section->get_bfd_owner ();
265
266   /* Make sure that at least there's room for the total_length field.
267      That could be 12 bytes long, but we're just going to fudge that.  */
268   if (to_underlying (sect_off) + 4 >= section->size)
269     {
270       dwarf2_statement_list_fits_in_line_number_section_complaint ();
271       return 0;
272     }
273
274   line_header_up lh (new line_header (comp_dir));
275
276   lh->sect_off = sect_off;
277   lh->offset_in_dwz = is_dwz;
278
279   line_ptr = section->buffer + to_underlying (sect_off);
280
281   /* Read in the header.  */
282   LONGEST unit_length
283     = read_checked_initial_length_and_offset (abfd, line_ptr, cu_header,
284                                               &bytes_read, &offset_size);
285   line_ptr += bytes_read;
286
287   const gdb_byte *start_here = line_ptr;
288
289   if (line_ptr + unit_length > (section->buffer + section->size))
290     {
291       dwarf2_statement_list_fits_in_line_number_section_complaint ();
292       return 0;
293     }
294   lh->statement_program_end = start_here + unit_length;
295   lh->version = read_2_bytes (abfd, line_ptr);
296   line_ptr += 2;
297   if (lh->version > 5)
298     {
299       /* This is a version we don't understand.  The format could have
300          changed in ways we don't handle properly so just punt.  */
301       complaint (_("unsupported version in .debug_line section"));
302       return NULL;
303     }
304   if (lh->version >= 5)
305     {
306       gdb_byte segment_selector_size;
307
308       /* Skip address size.  */
309       read_1_byte (abfd, line_ptr);
310       line_ptr += 1;
311
312       segment_selector_size = read_1_byte (abfd, line_ptr);
313       line_ptr += 1;
314       if (segment_selector_size != 0)
315         {
316           complaint (_("unsupported segment selector size %u "
317                        "in .debug_line section"),
318                      segment_selector_size);
319           return NULL;
320         }
321     }
322
323   LONGEST header_length = read_offset (abfd, line_ptr, offset_size);
324   line_ptr += offset_size;
325   lh->statement_program_start = line_ptr + header_length;
326   lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
327   line_ptr += 1;
328
329   if (lh->version >= 4)
330     {
331       lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
332       line_ptr += 1;
333     }
334   else
335     lh->maximum_ops_per_instruction = 1;
336
337   if (lh->maximum_ops_per_instruction == 0)
338     {
339       lh->maximum_ops_per_instruction = 1;
340       complaint (_("invalid maximum_ops_per_instruction "
341                    "in `.debug_line' section"));
342     }
343
344   lh->default_is_stmt = read_1_byte (abfd, line_ptr);
345   line_ptr += 1;
346   lh->line_base = read_1_signed_byte (abfd, line_ptr);
347   line_ptr += 1;
348   lh->line_range = read_1_byte (abfd, line_ptr);
349   line_ptr += 1;
350   lh->opcode_base = read_1_byte (abfd, line_ptr);
351   line_ptr += 1;
352   lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
353
354   lh->standard_opcode_lengths[0] = 1;  /* This should never be used anyway.  */
355   for (i = 1; i < lh->opcode_base; ++i)
356     {
357       lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
358       line_ptr += 1;
359     }
360
361   if (lh->version >= 5)
362     {
363       /* Read directory table.  */
364       read_formatted_entries (per_objfile, abfd, &line_ptr, lh.get (),
365                               offset_size,
366                               [] (struct line_header *header, const char *name,
367                                   dir_index d_index, unsigned int mod_time,
368                                   unsigned int length)
369         {
370           header->add_include_dir (name);
371         });
372
373       /* Read file name table.  */
374       read_formatted_entries (per_objfile, abfd, &line_ptr, lh.get (),
375                               offset_size,
376                               [] (struct line_header *header, const char *name,
377                                   dir_index d_index, unsigned int mod_time,
378                                   unsigned int length)
379         {
380           header->add_file_name (name, d_index, mod_time, length);
381         });
382     }
383   else
384     {
385       /* Read directory table.  */
386       while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
387         {
388           line_ptr += bytes_read;
389           lh->add_include_dir (cur_dir);
390         }
391       line_ptr += bytes_read;
392
393       /* Read file name table.  */
394       while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
395         {
396           unsigned int mod_time, length;
397           dir_index d_index;
398
399           line_ptr += bytes_read;
400           d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
401           line_ptr += bytes_read;
402           mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
403           line_ptr += bytes_read;
404           length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
405           line_ptr += bytes_read;
406
407           lh->add_file_name (cur_file, d_index, mod_time, length);
408         }
409       line_ptr += bytes_read;
410     }
411
412   if (line_ptr > (section->buffer + section->size))
413     complaint (_("line number info header doesn't "
414                  "fit in `.debug_line' section"));
415
416   return lh;
417 }
This page took 0.047912 seconds and 4 git commands to generate.