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" 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 /* 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 256 line_header_up 257 dwarf_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 { 274 dwarf2_statement_list_fits_in_line_number_section_complaint (); 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 { 295 dwarf2_statement_list_fits_in_line_number_section_complaint (); 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; 401 dir_index d_index; 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 } 422