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