GDB (xrefs)
Loading...
Searching...
No Matches
line-header.c
Go to the documentation of this file.
1/* DWARF 2 debugging format support for GDB.
2
3 Copyright (C) 1994-2023 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"
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
29void
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
45void
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
60std::string
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
83static 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
97static LONGEST
98read_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
121static void
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,
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 /* Normalize nullptr string. */
219 if (string.has_value () && *string == nullptr)
220 string.emplace ("");
221
222 switch (content_type)
223 {
224 case DW_LNCT_path:
225 if (string.has_value ())
226 fe.name = *string;
227 break;
228 case DW_LNCT_directory_index:
229 if (uint.has_value ())
230 fe.d_index = (dir_index) *uint;
231 break;
232 case DW_LNCT_timestamp:
233 if (uint.has_value ())
234 fe.mod_time = *uint;
235 break;
236 case DW_LNCT_size:
237 if (uint.has_value ())
238 fe.length = *uint;
239 break;
240 case DW_LNCT_MD5:
241 break;
242 default:
243 complaint (_("Unknown format content type %s"),
244 pulongest (content_type));
245 }
246 }
247
248 callback (lh, fe.name, fe.d_index, fe.mod_time, fe.length);
249 }
250
251 *bufp = buf;
252}
253
254/* See line-header.h. */
255
257dwarf_decode_line_header (sect_offset sect_off, bool is_dwz,
258 dwarf2_per_objfile *per_objfile,
259 struct dwarf2_section_info *section,
260 const struct comp_unit_head *cu_header,
261 const char *comp_dir)
262{
263 const gdb_byte *line_ptr;
264 unsigned int bytes_read, offset_size;
265 int i;
266 const char *cur_dir, *cur_file;
267
268 bfd *abfd = section->get_bfd_owner ();
269
270 /* Make sure that at least there's room for the total_length field.
271 That could be 12 bytes long, but we're just going to fudge that. */
272 if (to_underlying (sect_off) + 4 >= section->size)
273 {
275 return 0;
276 }
277
278 line_header_up lh (new line_header (comp_dir));
279
280 lh->sect_off = sect_off;
281 lh->offset_in_dwz = is_dwz;
282
283 line_ptr = section->buffer + to_underlying (sect_off);
284
285 /* Read in the header. */
286 LONGEST unit_length
287 = read_checked_initial_length_and_offset (abfd, line_ptr, cu_header,
288 &bytes_read, &offset_size);
289 line_ptr += bytes_read;
290
291 const gdb_byte *start_here = line_ptr;
292
293 if (line_ptr + unit_length > (section->buffer + section->size))
294 {
296 return 0;
297 }
298 lh->statement_program_end = start_here + unit_length;
299 lh->version = read_2_bytes (abfd, line_ptr);
300 line_ptr += 2;
301 if (lh->version > 5)
302 {
303 /* This is a version we don't understand. The format could have
304 changed in ways we don't handle properly so just punt. */
305 complaint (_("unsupported version in .debug_line section"));
306 return NULL;
307 }
308 if (lh->version >= 5)
309 {
310 gdb_byte segment_selector_size;
311
312 /* Skip address size. */
313 read_1_byte (abfd, line_ptr);
314 line_ptr += 1;
315
316 segment_selector_size = read_1_byte (abfd, line_ptr);
317 line_ptr += 1;
318 if (segment_selector_size != 0)
319 {
320 complaint (_("unsupported segment selector size %u "
321 "in .debug_line section"),
322 segment_selector_size);
323 return NULL;
324 }
325 }
326
327 LONGEST header_length = read_offset (abfd, line_ptr, offset_size);
328 line_ptr += offset_size;
329 lh->statement_program_start = line_ptr + header_length;
330 lh->minimum_instruction_length = read_1_byte (abfd, line_ptr);
331 line_ptr += 1;
332
333 if (lh->version >= 4)
334 {
335 lh->maximum_ops_per_instruction = read_1_byte (abfd, line_ptr);
336 line_ptr += 1;
337 }
338 else
339 lh->maximum_ops_per_instruction = 1;
340
341 if (lh->maximum_ops_per_instruction == 0)
342 {
343 lh->maximum_ops_per_instruction = 1;
344 complaint (_("invalid maximum_ops_per_instruction "
345 "in `.debug_line' section"));
346 }
347
348 lh->default_is_stmt = read_1_byte (abfd, line_ptr);
349 line_ptr += 1;
350 lh->line_base = read_1_signed_byte (abfd, line_ptr);
351 line_ptr += 1;
352 lh->line_range = read_1_byte (abfd, line_ptr);
353 line_ptr += 1;
354 lh->opcode_base = read_1_byte (abfd, line_ptr);
355 line_ptr += 1;
356 lh->standard_opcode_lengths.reset (new unsigned char[lh->opcode_base]);
357
358 lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
359 for (i = 1; i < lh->opcode_base; ++i)
360 {
361 lh->standard_opcode_lengths[i] = read_1_byte (abfd, line_ptr);
362 line_ptr += 1;
363 }
364
365 if (lh->version >= 5)
366 {
367 /* Read directory table. */
368 read_formatted_entries (per_objfile, abfd, &line_ptr, lh.get (),
369 offset_size,
370 [] (struct line_header *header, const char *name,
371 dir_index d_index, unsigned int mod_time,
372 unsigned int length)
373 {
374 header->add_include_dir (name);
375 });
376
377 /* Read file name table. */
378 read_formatted_entries (per_objfile, abfd, &line_ptr, lh.get (),
379 offset_size,
380 [] (struct line_header *header, const char *name,
381 dir_index d_index, unsigned int mod_time,
382 unsigned int length)
383 {
384 header->add_file_name (name, d_index, mod_time, length);
385 });
386 }
387 else
388 {
389 /* Read directory table. */
390 while ((cur_dir = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
391 {
392 line_ptr += bytes_read;
393 lh->add_include_dir (cur_dir);
394 }
395 line_ptr += bytes_read;
396
397 /* Read file name table. */
398 while ((cur_file = read_direct_string (abfd, line_ptr, &bytes_read)) != NULL)
399 {
400 unsigned int mod_time, length;
402
403 line_ptr += bytes_read;
404 d_index = (dir_index) read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
405 line_ptr += bytes_read;
406 mod_time = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
407 line_ptr += bytes_read;
408 length = read_unsigned_leb128 (abfd, line_ptr, &bytes_read);
409 line_ptr += bytes_read;
410
411 lh->add_file_name (cur_file, d_index, mod_time, length);
412 }
413 line_ptr += bytes_read;
414 }
415
416 if (line_ptr > (section->buffer + section->size))
417 complaint (_("line number info header doesn't "
418 "fit in `.debug_line' section"));
419
420 return lh;
421}
const char *const name
#define complaint(FMT,...)
Definition complaints.h:47
LONGEST read_initial_length(bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read, bool handle_nonstd)
Definition leb.c:90
ULONGEST read_unsigned_leb128(bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read_ptr)
Definition leb.c:31
LONGEST read_offset(bfd *abfd, const gdb_byte *buf, unsigned int offset_size)
Definition leb.c:117
static unsigned int read_4_bytes(bfd *abfd, const gdb_byte *buf)
Definition leb.h:64
static const char * read_direct_string(bfd *abfd, const gdb_byte *buf, unsigned int *bytes_read_ptr)
Definition leb.h:141
static unsigned int read_1_byte(bfd *abfd, const gdb_byte *buf)
Definition leb.h:33
static int read_1_signed_byte(bfd *abfd, const gdb_byte *buf)
Definition leb.h:39
static unsigned int read_2_bytes(bfd *abfd, const gdb_byte *buf)
Definition leb.h:45
static ULONGEST read_8_bytes(bfd *abfd, const gdb_byte *buf)
Definition leb.h:76
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, const char *comp_dir)
static void read_formatted_entries(dwarf2_per_objfile *per_objfile, bfd *abfd, const gdb_byte **bufp, struct line_header *lh, unsigned int offset_size, void(*callback)(struct line_header *lh, const char *name, dir_index d_index, unsigned int mod_time, unsigned int length))
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)
Definition line-header.c:98
static void dwarf2_statement_list_fits_in_line_number_section_complaint(void)
Definition line-header.c:84
int file_name_index
Definition line-header.h:29
std::unique_ptr< line_header > line_header_up
int dir_index
Definition line-header.h:25
unsigned int dwarf_line_debug
Definition read.c:120
unsigned int initial_length_size
const char * read_line_string(const gdb_byte *buf, const struct comp_unit_head *cu_header, unsigned int *bytes_read_ptr)
Definition read.c:17551
const gdb_byte * buffer
Definition section.h:115
bfd_size_type size
Definition section.h:117
struct bfd * get_bfd_owner() const
Definition section.c:49
Definition line-header.h:34
dir_index d_index
Definition line-header.h:58
file_name_index index
Definition line-header.h:55
unsigned int length
Definition line-header.h:62
unsigned int mod_time
Definition line-header.h:60
const char * name
Definition line-header.h:52
const char * include_dir(const line_header *lh) const
const char * m_comp_dir
unsigned short version
std::string file_file_name(const file_entry &fe) const
Definition line-header.c:61
void add_include_dir(const char *include_dir)
Definition line-header.c:30
void add_file_name(const char *name, dir_index d_index, unsigned int mod_time, unsigned int length)
Definition line-header.c:46
bool is_valid_file_index(int file_index) const
std::vector< const char * > m_include_dirs
std::vector< file_entry > m_file_names
int file_names_size() const
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
#define gdb_stdlog
Definition utils.h:190