1 /* DWARF 2 debugging format support for GDB.
3 Copyright (C) 1994-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
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"
29 line_header::add_include_dir (const char *include_dir
)
31 if (dwarf_line_debug
>= 2)
35 new_size
= m_include_dirs
.size ();
37 new_size
= m_include_dirs
.size () + 1;
38 fprintf_unfiltered (gdb_stdlog
, "Adding dir %zu: %s\n",
39 new_size
, include_dir
);
41 m_include_dirs
.push_back (include_dir
);
45 line_header::add_file_name (const char *name
,
47 unsigned int mod_time
,
50 if (dwarf_line_debug
>= 2)
54 new_size
= file_names_size ();
56 new_size
= file_names_size () + 1;
57 fprintf_unfiltered (gdb_stdlog
, "Adding file %zu: %s\n",
60 m_file_names
.emplace_back (name
, d_index
, mod_time
, length
);
63 gdb::unique_xmalloc_ptr
<char>
64 line_header::file_file_name (int file
) const
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
))
70 const file_entry
*fe
= file_name_at (file
);
72 if (!IS_ABSOLUTE_PATH (fe
->name
))
74 const char *dir
= fe
->include_dir (this);
76 return gdb::unique_xmalloc_ptr
<char> (concat (dir
, SLASH_STRING
,
80 return make_unique_xstrdup (fe
->name
);
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. */
89 xsnprintf (fake_name
, sizeof (fake_name
),
90 "<bad macro file number %d>", file
);
92 complaint (_("bad file number in macro information (%d)"),
95 return make_unique_xstrdup (fake_name
);
99 gdb::unique_xmalloc_ptr
<char>
100 line_header::file_full_name (int file
, const char *comp_dir
) const
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
))
106 gdb::unique_xmalloc_ptr
<char> relative
= file_file_name (file
);
108 if (IS_ABSOLUTE_PATH (relative
.get ()) || comp_dir
== NULL
)
110 return gdb::unique_xmalloc_ptr
<char> (concat (comp_dir
, SLASH_STRING
,
115 return file_file_name (file
);
119 dwarf2_statement_list_fits_in_line_number_section_complaint (void)
121 complaint (_("statement list doesn't fit in .debug_line section"));
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
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. */
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
)
138 LONGEST length
= read_initial_length (abfd
, buf
, bytes_read
);
140 gdb_assert (cu_header
->initial_length_size
== 4
141 || cu_header
->initial_length_size
== 8
142 || cu_header
->initial_length_size
== 12);
144 if (cu_header
->initial_length_size
!= *bytes_read
)
145 complaint (_("intermixed 32-bit and 64-bit DWARF sections"));
147 *offset_size
= (*bytes_read
== 4) ? 4 : 8;
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
157 read_formatted_entries (struct dwarf2_per_objfile
*dwarf2_per_objfile
,
158 bfd
*abfd
, const gdb_byte
**bufp
,
159 struct line_header
*lh
,
160 const struct comp_unit_head
*cu_header
,
161 void (*callback
) (struct line_header
*lh
,
164 unsigned int mod_time
,
165 unsigned int length
))
167 gdb_byte format_count
, formati
;
168 ULONGEST data_count
, datai
;
169 const gdb_byte
*buf
= *bufp
;
170 const gdb_byte
*format_header_data
;
171 unsigned int bytes_read
;
173 format_count
= read_1_byte (abfd
, buf
);
175 format_header_data
= buf
;
176 for (formati
= 0; formati
< format_count
; formati
++)
178 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
180 read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
184 data_count
= read_unsigned_leb128 (abfd
, buf
, &bytes_read
);
186 for (datai
= 0; datai
< data_count
; datai
++)
188 const gdb_byte
*format
= format_header_data
;
189 struct file_entry fe
;
191 for (formati
= 0; formati
< format_count
; formati
++)
193 ULONGEST content_type
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
194 format
+= bytes_read
;
196 ULONGEST form
= read_unsigned_leb128 (abfd
, format
, &bytes_read
);
197 format
+= bytes_read
;
199 gdb::optional
<const char *> string
;
200 gdb::optional
<unsigned int> uint
;
205 string
.emplace (read_direct_string (abfd
, buf
, &bytes_read
));
209 case DW_FORM_line_strp
:
211 (dwarf2_per_objfile
->read_line_string (buf
,
218 uint
.emplace (read_1_byte (abfd
, buf
));
223 uint
.emplace (read_2_bytes (abfd
, buf
));
228 uint
.emplace (read_4_bytes (abfd
, buf
));
233 uint
.emplace (read_8_bytes (abfd
, buf
));
238 /* This is used for MD5, but file_entry does not record MD5s. */
243 uint
.emplace (read_unsigned_leb128 (abfd
, buf
, &bytes_read
));
248 /* It is valid only for DW_LNCT_timestamp which is ignored by
253 switch (content_type
)
256 if (string
.has_value ())
259 case DW_LNCT_directory_index
:
260 if (uint
.has_value ())
261 fe
.d_index
= (dir_index
) *uint
;
263 case DW_LNCT_timestamp
:
264 if (uint
.has_value ())
268 if (uint
.has_value ())
274 complaint (_("Unknown format content type %s"),
275 pulongest (content_type
));
279 callback (lh
, fe
.name
, fe
.d_index
, fe
.mod_time
, fe
.length
);
285 /* See line-header.h. */
288 dwarf_decode_line_header (sect_offset sect_off
, bool is_dwz
,
289 struct dwarf2_per_objfile
*dwarf2_per_objfile
,
290 struct dwarf2_section_info
*section
,
291 const struct comp_unit_head
*cu_header
)
293 const gdb_byte
*line_ptr
;
294 unsigned int bytes_read
, offset_size
;
296 const char *cur_dir
, *cur_file
;
298 bfd
*abfd
= section
->get_bfd_owner ();
300 /* Make sure that at least there's room for the total_length field.
301 That could be 12 bytes long, but we're just going to fudge that. */
302 if (to_underlying (sect_off
) + 4 >= section
->size
)
304 dwarf2_statement_list_fits_in_line_number_section_complaint ();
308 line_header_up
lh (new line_header ());
310 lh
->sect_off
= sect_off
;
311 lh
->offset_in_dwz
= is_dwz
;
313 line_ptr
= section
->buffer
+ to_underlying (sect_off
);
315 /* Read in the header. */
317 read_checked_initial_length_and_offset (abfd
, line_ptr
, cu_header
,
318 &bytes_read
, &offset_size
);
319 line_ptr
+= bytes_read
;
321 const gdb_byte
*start_here
= line_ptr
;
323 if (line_ptr
+ lh
->total_length
> (section
->buffer
+ section
->size
))
325 dwarf2_statement_list_fits_in_line_number_section_complaint ();
328 lh
->statement_program_end
= start_here
+ lh
->total_length
;
329 lh
->version
= read_2_bytes (abfd
, line_ptr
);
333 /* This is a version we don't understand. The format could have
334 changed in ways we don't handle properly so just punt. */
335 complaint (_("unsupported version in .debug_line section"));
338 if (lh
->version
>= 5)
340 gdb_byte segment_selector_size
;
342 /* Skip address size. */
343 read_1_byte (abfd
, line_ptr
);
346 segment_selector_size
= read_1_byte (abfd
, line_ptr
);
348 if (segment_selector_size
!= 0)
350 complaint (_("unsupported segment selector size %u "
351 "in .debug_line section"),
352 segment_selector_size
);
356 lh
->header_length
= read_offset (abfd
, line_ptr
, offset_size
);
357 line_ptr
+= offset_size
;
358 lh
->statement_program_start
= line_ptr
+ lh
->header_length
;
359 lh
->minimum_instruction_length
= read_1_byte (abfd
, line_ptr
);
361 if (lh
->version
>= 4)
363 lh
->maximum_ops_per_instruction
= read_1_byte (abfd
, line_ptr
);
367 lh
->maximum_ops_per_instruction
= 1;
369 if (lh
->maximum_ops_per_instruction
== 0)
371 lh
->maximum_ops_per_instruction
= 1;
372 complaint (_("invalid maximum_ops_per_instruction "
373 "in `.debug_line' section"));
376 lh
->default_is_stmt
= read_1_byte (abfd
, line_ptr
);
378 lh
->line_base
= read_1_signed_byte (abfd
, line_ptr
);
380 lh
->line_range
= read_1_byte (abfd
, line_ptr
);
382 lh
->opcode_base
= read_1_byte (abfd
, line_ptr
);
384 lh
->standard_opcode_lengths
.reset (new unsigned char[lh
->opcode_base
]);
386 lh
->standard_opcode_lengths
[0] = 1; /* This should never be used anyway. */
387 for (i
= 1; i
< lh
->opcode_base
; ++i
)
389 lh
->standard_opcode_lengths
[i
] = read_1_byte (abfd
, line_ptr
);
393 if (lh
->version
>= 5)
395 /* Read directory table. */
396 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
398 [] (struct line_header
*header
, const char *name
,
399 dir_index d_index
, unsigned int mod_time
,
402 header
->add_include_dir (name
);
405 /* Read file name table. */
406 read_formatted_entries (dwarf2_per_objfile
, abfd
, &line_ptr
, lh
.get (),
408 [] (struct line_header
*header
, const char *name
,
409 dir_index d_index
, unsigned int mod_time
,
412 header
->add_file_name (name
, d_index
, mod_time
, length
);
417 /* Read directory table. */
418 while ((cur_dir
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
420 line_ptr
+= bytes_read
;
421 lh
->add_include_dir (cur_dir
);
423 line_ptr
+= bytes_read
;
425 /* Read file name table. */
426 while ((cur_file
= read_direct_string (abfd
, line_ptr
, &bytes_read
)) != NULL
)
428 unsigned int mod_time
, length
;
431 line_ptr
+= bytes_read
;
432 d_index
= (dir_index
) read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
433 line_ptr
+= bytes_read
;
434 mod_time
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
435 line_ptr
+= bytes_read
;
436 length
= read_unsigned_leb128 (abfd
, line_ptr
, &bytes_read
);
437 line_ptr
+= bytes_read
;
439 lh
->add_file_name (cur_file
, d_index
, mod_time
, length
);
441 line_ptr
+= bytes_read
;
444 if (line_ptr
> (section
->buffer
+ section
->size
))
445 complaint (_("line number info header doesn't "
446 "fit in `.debug_line' section"));