summaryrefslogtreecommitdiffstats
path: root/meta/recipes-devtools/binutils
diff options
context:
space:
mode:
authorMartin Jansa <Martin.Jansa@gmail.com>2021-05-12 18:45:03 +0200
committerRichard Purdie <richard.purdie@linuxfoundation.org>2021-05-13 11:34:15 +0100
commite7ce28c8b060fc4fc84fe328275bbca87d17a3f0 (patch)
tree67e82dac46f1a20a27f2201aaa6dac1da0b9aae6 /meta/recipes-devtools/binutils
parent0fc0804e4b6df74aa160cab75e9da944013b0db3 (diff)
downloadpoky-e7ce28c8b060fc4fc84fe328275bbca87d17a3f0.tar.gz
binutils: backport DWARF-5 support for gold
* DWARF-5 is now used by default with gcc-11, causing 11.1.0/ld: internal error in format_file_lineno, at ../../gold/dwarf_reader.cc:2278 collect2: error: ld returned 1 exit status in various projects (runc-opencontainers, libhybris, collada-dom) * https://gcc.gnu.org/gcc-11/changes.html For targets that produce DWARF debugging information GCC now defaults to DWARF version 5 (with the exception of VxWorks and Darwin/Mac OS X which default to version 2 and AIX which defaults to version 4). This can produce up to 25% more compact debug information compared to earlier versions. To take full advantage of DWARF version 5 GCC needs to be build against binutils version 2.35.2 or higher. When GCC is build against earlier versions of binutils GCC will still emit DWARF version 5 for most debuginfo data, but will generate version 4 debug line tables (even when explicitly given -gdwarf-5). The following debug information consumers can process DWARF version 5: GDB 8.0, or higher valgrind 3.17.0 elfutils 0.172, or higher (for use with systemtap, dwarves/pahole, perf and libabigail) dwz 0.14 Programs embedding libbacktrace are urged to upgrade to the version shipping with GCC 11. To make GCC 11 generate an older DWARF version use -g together with -gdwarf-2, -gdwarf-3 or -gdwarf-4. (From OE-Core rev: d07d4d739ae17787017f771dd2068fda0e836722) Signed-off-by: Martin Jansa <Martin.Jansa@gmail.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
Diffstat (limited to 'meta/recipes-devtools/binutils')
-rw-r--r--meta/recipes-devtools/binutils/binutils-2.36.inc1
-rw-r--r--meta/recipes-devtools/binutils/binutils/0018-Add-DWARF-5-support-in-gold.patch1374
2 files changed, 1375 insertions, 0 deletions
diff --git a/meta/recipes-devtools/binutils/binutils-2.36.inc b/meta/recipes-devtools/binutils/binutils-2.36.inc
index 66080dfcee..d54e2a3457 100644
--- a/meta/recipes-devtools/binutils/binutils-2.36.inc
+++ b/meta/recipes-devtools/binutils/binutils-2.36.inc
@@ -36,6 +36,7 @@ SRC_URI = "\
36 file://0015-sync-with-OE-libtool-changes.patch \ 36 file://0015-sync-with-OE-libtool-changes.patch \
37 file://0016-Check-for-clang-before-checking-gcc-version.patch \ 37 file://0016-Check-for-clang-before-checking-gcc-version.patch \
38 file://0017-Add-support-for-the-DW_FORM_strx-forms-to-the-BFD-li.patch \ 38 file://0017-Add-support-for-the-DW_FORM_strx-forms-to-the-BFD-li.patch \
39 file://0018-Add-DWARF-5-support-in-gold.patch \
39 file://CVE-2021-20197.patch \ 40 file://CVE-2021-20197.patch \
40" 41"
41S = "${WORKDIR}/git" 42S = "${WORKDIR}/git"
diff --git a/meta/recipes-devtools/binutils/binutils/0018-Add-DWARF-5-support-in-gold.patch b/meta/recipes-devtools/binutils/binutils/0018-Add-DWARF-5-support-in-gold.patch
new file mode 100644
index 0000000000..353b680857
--- /dev/null
+++ b/meta/recipes-devtools/binutils/binutils/0018-Add-DWARF-5-support-in-gold.patch
@@ -0,0 +1,1374 @@
1From 29dab7648672342418a9d32767e3b3182d9e6a30 Mon Sep 17 00:00:00 2001
2From: Cary Coutant <ccoutant@gmail.com>
3Date: Wed, 17 Mar 2021 21:31:15 -0700
4Subject: [PATCH] Add DWARF 5 support in gold.
5
6elfcpp/
7 PR gold/27246
8 * dwarf.h (enum DW_LNCT): Add line number table content type codes.
9 (enum DW_LINE_OPS): Reformat.
10 (enum DW_LINE_EXTENDED_OPS): Reformat.
11 (enum DW_CHILDREN): Reformat.
12 (enum DW_RLE): Add range list entry types.
13 (enum DW_SECT): Update values for DWARF 5.
14
15gold/
16 PR gold/27246
17 * dwarf_reader.cc (Dwarf_abbrev_table::do_get_abbrev): Handle
18 DW_FORM_implicit_const.
19 (Dwarf_ranges_table::read_ranges_table): Add version parameter;
20 Adjust all callers. Look for .debug_rnglists section if DWARF 5.
21 (Dwarf_ranges_table::read_range_list_v5): New method.
22 (Dwarf_die::read_attributes): Handle new DWARF 5 DW_FORM codes.
23 (Dwarf_die::skip_attributes): Likewise.
24 (Dwarf_info_reader::do_parse): Support DWARF 5 unit header format.
25 (Dwarf_info_reader::read_3bytes_from_pointer): New method.
26 (Sized_dwarf_line_info::Sized_dwarf_line_info): Initialize
27 str_buffer_, str_buffer_start, reloc_map_, line_number_map_.
28 Look for .debug_line_str section.
29 (Sized_dwarf_line_info::read_header_prolog): Support DWARF 5 prolog.
30 (Sized_dwarf_line_info::read_header_tables): Rename to...
31 (Sized_dwarf_line_info::read_header_tables_v2): ... this.
32 (Sized_dwarf_line_info::read_header_tables_v5): New method.
33 (Sized_dwarf_line_info::process_one_opcode): Insert missing "this->".
34 Change advance_line to signed int64_t.
35 (Sized_dwarf_line_info::read_lines): Add endptr parameter; adjust
36 callers. Insert missing "this->".
37 (Sized_dwarf_line_info::read_line_mappings): Support DWARF 5.
38 (Sized_dwarf_line_info::do_addr2line): Add debug code.
39 * dwarf_reader.h (Dwarf_abbrev_table::Attribute): Add implicit_const
40 field. Adjust constructor.
41 (Dwarf_abbrev_table::add_sttribute): Add implicit_const parameter.
42 (Dwarf_ranges_table::read_ranges_table): Add version parameter.
43 (Dwarf_ranges_table::read_range_list_v5): New method.
44 (Dwarf_die): Remove unused attr_off field.
45 (Dwarf_info_reader::Dwarf_info_reader): Initialize unit_type_ field.
46 (Dwarf_info_reader::is_type_unit): New method.
47 (Dwarf_info_reader::read_3bytes_from_pointer): New method.
48 (Dwarf_info_reader::read_range_list): Call read_range_list_v5 for
49 DWARF 5 range lists.
50 (Dwarf_info_reader::is_type_unit_): Remove.
51 (Dwarf_info_reader::unit_type_): New field.
52 (Sized_dwarf_line_info::~Sized_dwarf_line_info): Delete
53 str_buffer_start_.
54 (Sized_dwarf_line_info::read_header_tables): Rename to...
55 (Sized_dwarf_line_info::read_header_tables_v2): ... this.
56 (Sized_dwarf_line_info::read_header_tables_v5): New method.
57 (Sized_dwarf_line_info::read_lines): Add endptr parameter.
58 (Sized_dwarf_line_info::Dwarf_line_infoHeader): Add address_size field.
59 (Sized_dwarf_line_info::str_buffer_): New field.
60 (Sized_dwarf_line_info::str_buffer_end_): New field.
61 (Sized_dwarf_line_info::str_buffer_start_): New field.
62 (Sized_dwarf_line_info::end_of_header_length_): New field.
63 (Sized_dwarf_line_info::end_of_unit_): New field.
64
65Upstream-Status: Backport [5cde809b7b9 Add DWARF 5 support in gold.]
66
67Signed-off-by: Martin Jansa <Martin.Jansa@gmail.com>
68---
69 elfcpp/dwarf.h | 89 +++++--
70 gold/dwarf_reader.cc | 591 +++++++++++++++++++++++++++++++++++++------
71 gold/dwarf_reader.h | 103 ++++++--
72 3 files changed, 654 insertions(+), 129 deletions(-)
73
74diff --git a/elfcpp/dwarf.h b/elfcpp/dwarf.h
75index e24347f8481..c9a9e02369c 100644
76--- a/elfcpp/dwarf.h
77+++ b/elfcpp/dwarf.h
78@@ -152,35 +152,48 @@ enum DW_EH_PE
79 DW_EH_PE_indirect = 0x80
80 };
81
82+// Line number table content type codes.
83+
84+enum DW_LNCT
85+{
86+ DW_LNCT_path = 0x1,
87+ DW_LNCT_directory_index = 0x2,
88+ DW_LNCT_timestamp = 0x3,
89+ DW_LNCT_size = 0x4,
90+ DW_LNCT_MD5 = 0x5,
91+ DW_LNCT_lo_user = 0x2000,
92+ DW_LNCT_hi_user = 0x3fff
93+};
94+
95 // Line number opcodes.
96
97 enum DW_LINE_OPS
98 {
99- DW_LNS_extended_op = 0,
100- DW_LNS_copy = 1,
101- DW_LNS_advance_pc = 2,
102- DW_LNS_advance_line = 3,
103- DW_LNS_set_file = 4,
104- DW_LNS_set_column = 5,
105- DW_LNS_negate_stmt = 6,
106- DW_LNS_set_basic_block = 7,
107- DW_LNS_const_add_pc = 8,
108- DW_LNS_fixed_advance_pc = 9,
109+ DW_LNS_extended_op = 0x00,
110+ DW_LNS_copy = 0x01,
111+ DW_LNS_advance_pc = 0x02,
112+ DW_LNS_advance_line = 0x03,
113+ DW_LNS_set_file = 0x04,
114+ DW_LNS_set_column = 0x05,
115+ DW_LNS_negate_stmt = 0x06,
116+ DW_LNS_set_basic_block = 0x07,
117+ DW_LNS_const_add_pc = 0x08,
118+ DW_LNS_fixed_advance_pc = 0x09,
119 // DWARF 3.
120- DW_LNS_set_prologue_end = 10,
121- DW_LNS_set_epilogue_begin = 11,
122- DW_LNS_set_isa = 12
123+ DW_LNS_set_prologue_end = 0x0a,
124+ DW_LNS_set_epilogue_begin = 0x0b,
125+ DW_LNS_set_isa = 0x0c
126 };
127
128 // Line number extended opcodes.
129
130 enum DW_LINE_EXTENDED_OPS
131 {
132- DW_LNE_end_sequence = 1,
133- DW_LNE_set_address = 2,
134- DW_LNE_define_file = 3,
135+ DW_LNE_end_sequence = 0x01,
136+ DW_LNE_set_address = 0x02,
137+ DW_LNE_define_file = 0x03,
138 // DWARF4.
139- DW_LNE_set_discriminator = 4,
140+ DW_LNE_set_discriminator = 0x04,
141 // HP extensions.
142 DW_LNE_HP_negate_is_UV_update = 0x11,
143 DW_LNE_HP_push_context = 0x12,
144@@ -191,13 +204,15 @@ enum DW_LINE_EXTENDED_OPS
145 DW_LNE_HP_negate_post_semantics = 0x17,
146 DW_LNE_HP_negate_function_exit = 0x18,
147 DW_LNE_HP_negate_front_end_logical = 0x19,
148- DW_LNE_HP_define_proc = 0x20
149+ DW_LNE_HP_define_proc = 0x20,
150+ DW_LNE_lo_user = 0x80,
151+ DW_LNE_hi_user = 0xff
152 };
153
154 enum DW_CHILDREN
155 {
156- DW_CHILDREN_no =0x00,
157- DW_CHILDREN_yes =0x01
158+ DW_CHILDREN_no = 0,
159+ DW_CHILDREN_yes = 1
160 };
161
162 // Source language names and codes.
163@@ -247,20 +262,38 @@ enum DW_LANG
164 DW_LANG_HP_Assembler = 0x8007
165 };
166
167+// Range list entry kinds in .debug_rnglists* section.
168+
169+enum DW_RLE
170+{
171+ DW_RLE_end_of_list = 0x00,
172+ DW_RLE_base_addressx = 0x01,
173+ DW_RLE_startx_endx = 0x02,
174+ DW_RLE_startx_length = 0x03,
175+ DW_RLE_offset_pair = 0x04,
176+ DW_RLE_base_address = 0x05,
177+ DW_RLE_start_end = 0x06,
178+ DW_RLE_start_length = 0x07
179+};
180+
181 // DWARF section identifiers used in the package format.
182 // Extensions for Fission. See http://gcc.gnu.org/wiki/DebugFissionDWP.
183+// Added (with changes) in DWARF 5.
184
185 enum DW_SECT
186 {
187- DW_SECT_INFO = 1,
188- DW_SECT_TYPES = 2,
189- DW_SECT_ABBREV = 3,
190- DW_SECT_LINE = 4,
191- DW_SECT_LOC = 5,
192+ DW_SECT_INFO = 1,
193+ DW_SECT_ABBREV = 3,
194+ DW_SECT_LINE = 4,
195+ DW_SECT_LOCLISTS = 5,
196 DW_SECT_STR_OFFSETS = 6,
197- DW_SECT_MACINFO = 7,
198- DW_SECT_MACRO = 8,
199- DW_SECT_MAX = DW_SECT_MACRO,
200+ DW_SECT_MACINFO = 7,
201+ DW_SECT_RNGLISTS = 8,
202+ DW_SECT_MAX = DW_SECT_RNGLISTS,
203+ // These were used only for the experimental Fission support in DWARF 4.
204+ DW_SECT_TYPES = 2,
205+ DW_SECT_LOC = 5,
206+ DW_SECT_MACRO = 8
207 };
208
209 } // End namespace elfcpp.
210diff --git a/gold/dwarf_reader.cc b/gold/dwarf_reader.cc
211index f0e6b89bde2..83a0114ed39 100644
212--- a/gold/dwarf_reader.cc
213+++ b/gold/dwarf_reader.cc
214@@ -26,6 +26,7 @@
215 #include <utility>
216 #include <vector>
217
218+#include "debug.h"
219 #include "elfcpp_swap.h"
220 #include "dwarf.h"
221 #include "object.h"
222@@ -275,6 +276,14 @@ Dwarf_abbrev_table::do_get_abbrev(unsigned int code)
223 uint64_t form = read_unsigned_LEB_128(this->buffer_pos_, &len);
224 this->buffer_pos_ += len;
225
226+ // For DW_FORM_implicit_const, read the constant.
227+ int64_t implicit_const = 0;
228+ if (form == elfcpp::DW_FORM_implicit_const)
229+ {
230+ implicit_const = read_signed_LEB_128(this->buffer_pos_, &len);
231+ this->buffer_pos_ += len;
232+ }
233+
234 // A (0,0) pair terminates the list.
235 if (attr == 0 && form == 0)
236 break;
237@@ -282,7 +291,7 @@ Dwarf_abbrev_table::do_get_abbrev(unsigned int code)
238 if (attr == elfcpp::DW_AT_sibling)
239 entry->has_sibling_attribute = true;
240
241- entry->add_attribute(attr, form);
242+ entry->add_attribute(attr, form, implicit_const);
243 }
244
245 this->store_abbrev(nextcode, entry);
246@@ -302,8 +311,16 @@ Dwarf_ranges_table::read_ranges_table(
247 Relobj* object,
248 const unsigned char* symtab,
249 off_t symtab_size,
250- unsigned int ranges_shndx)
251+ unsigned int ranges_shndx,
252+ unsigned int version)
253 {
254+ const std::string section_name(version < 5
255+ ? ".debug_ranges"
256+ : ".debug_rnglists");
257+ const std::string compressed_section_name(version < 5
258+ ? ".zdebug_ranges"
259+ : ".zdebug_rnglists");
260+
261 // If we've already read this abbrev table, return immediately.
262 if (this->ranges_shndx_ > 0
263 && this->ranges_shndx_ == ranges_shndx)
264@@ -318,7 +335,7 @@ Dwarf_ranges_table::read_ranges_table(
265 for (unsigned int i = 1; i < object->shnum(); ++i)
266 {
267 std::string name = object->section_name(i);
268- if (name == ".debug_ranges" || name == ".zdebug_ranges")
269+ if (name == section_name || name == compressed_section_name)
270 {
271 ranges_shndx = i;
272 this->output_section_offset_ = object->output_section_offset(i);
273@@ -393,7 +410,7 @@ Dwarf_ranges_table::read_range_list(
274 {
275 Dwarf_range_list* ranges;
276
277- if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx))
278+ if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx, 4))
279 return NULL;
280
281 // Correct the offset. For incremental update links, we have a
282@@ -459,6 +476,125 @@ Dwarf_ranges_table::read_range_list(
283 return ranges;
284 }
285
286+// Read a DWARF 5 range list from section RANGES_SHNDX at offset RANGES_OFFSET.
287+
288+Dwarf_range_list*
289+Dwarf_ranges_table::read_range_list_v5(
290+ Relobj* object,
291+ const unsigned char* symtab,
292+ off_t symtab_size,
293+ unsigned int addr_size,
294+ unsigned int ranges_shndx,
295+ off_t offset)
296+{
297+ Dwarf_range_list* ranges;
298+
299+ if (!this->read_ranges_table(object, symtab, symtab_size, ranges_shndx, 5))
300+ return NULL;
301+
302+ ranges = new Dwarf_range_list();
303+ off_t base = 0;
304+ unsigned int shndx0 = 0;
305+
306+ // Correct the offset. For incremental update links, we have a
307+ // relocated offset that is relative to the output section, but
308+ // here we need an offset relative to the input section.
309+ offset -= this->output_section_offset_;
310+
311+ // Read the range list at OFFSET.
312+ const unsigned char* prle = this->ranges_buffer_ + offset;
313+ while (prle < this->ranges_buffer_end_)
314+ {
315+ off_t start;
316+ off_t end;
317+ unsigned int shndx1 = 0;
318+ unsigned int shndx2 = 0;
319+ size_t len;
320+
321+ // Read the entry type.
322+ unsigned int rle_type = *prle++;
323+ offset += 1;
324+
325+ if (rle_type == elfcpp::DW_RLE_end_of_list)
326+ break;
327+
328+ switch (rle_type)
329+ {
330+ case elfcpp::DW_RLE_base_address:
331+ if (addr_size == 4)
332+ base = this->dwinfo_->read_from_pointer<32>(prle);
333+ else
334+ base = this->dwinfo_->read_from_pointer<64>(prle);
335+ if (this->ranges_reloc_mapper_ != NULL)
336+ shndx0 = this->lookup_reloc(offset, &base);
337+ prle += addr_size;
338+ offset += addr_size;
339+ break;
340+
341+ case elfcpp::DW_RLE_offset_pair:
342+ start = read_unsigned_LEB_128(prle, &len);
343+ prle += len;
344+ offset += len;
345+ end = read_unsigned_LEB_128(prle, &len);
346+ prle += len;
347+ offset += len;
348+ if (shndx0 == 0 || object->is_section_included(shndx0))
349+ ranges->add(shndx0, base + start, base + end);
350+ break;
351+
352+ case elfcpp::DW_RLE_start_end:
353+ if (addr_size == 4)
354+ {
355+ start = this->dwinfo_->read_from_pointer<32>(prle);
356+ end = this->dwinfo_->read_from_pointer<32>(prle + 4);
357+ }
358+ else
359+ {
360+ start = this->dwinfo_->read_from_pointer<64>(prle);
361+ end = this->dwinfo_->read_from_pointer<64>(prle + 8);
362+ }
363+ if (this->ranges_reloc_mapper_ != NULL)
364+ {
365+ shndx1 = this->lookup_reloc(offset, &start);
366+ shndx2 = this->lookup_reloc(offset + addr_size, &end);
367+ if (shndx1 != shndx2)
368+ gold_warning(_("%s: DWARF info may be corrupt; offsets in a "
369+ "range list entry are in different sections"),
370+ object->name().c_str());
371+ }
372+ prle += addr_size * 2;
373+ offset += addr_size * 2;
374+ if (shndx1 == 0 || object->is_section_included(shndx1))
375+ ranges->add(shndx1, start, end);
376+ break;
377+
378+ case elfcpp::DW_RLE_start_length:
379+ if (addr_size == 4)
380+ start = this->dwinfo_->read_from_pointer<32>(prle);
381+ else
382+ start = this->dwinfo_->read_from_pointer<64>(prle);
383+ if (this->ranges_reloc_mapper_ != NULL)
384+ shndx1 = this->lookup_reloc(offset, &start);
385+ prle += addr_size;
386+ offset += addr_size;
387+ end = start + read_unsigned_LEB_128(prle, &len);
388+ prle += len;
389+ offset += len;
390+ if (shndx1 == 0 || object->is_section_included(shndx1))
391+ ranges->add(shndx1, start, end);
392+ break;
393+
394+ default:
395+ gold_warning(_("%s: DWARF range list contains "
396+ "unsupported entry type (%d)"),
397+ object->name().c_str(), rle_type);
398+ break;
399+ }
400+ }
401+
402+ return ranges;
403+}
404+
405 // Look for a relocation at offset OFF in the range table,
406 // and return the section index and offset of the target.
407
408@@ -709,7 +845,13 @@ Dwarf_die::read_attributes()
409 case elfcpp::DW_FORM_flag_present:
410 attr_value.val.intval = 1;
411 break;
412+ case elfcpp::DW_FORM_implicit_const:
413+ attr_value.val.intval =
414+ this->abbrev_code_->attributes[i].implicit_const;
415+ break;
416 case elfcpp::DW_FORM_strp:
417+ case elfcpp::DW_FORM_strp_sup:
418+ case elfcpp::DW_FORM_line_strp:
419 {
420 off_t str_off;
421 if (this->dwinfo_->offset_size() == 4)
422@@ -722,6 +864,26 @@ Dwarf_die::read_attributes()
423 attr_value.val.refval = str_off;
424 break;
425 }
426+ case elfcpp::DW_FORM_strx:
427+ case elfcpp::DW_FORM_GNU_str_index:
428+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
429+ pattr += len;
430+ break;
431+ case elfcpp::DW_FORM_strx1:
432+ attr_value.val.uintval = *pattr++;
433+ break;
434+ case elfcpp::DW_FORM_strx2:
435+ attr_value.val.uintval =
436+ this->dwinfo_->read_from_pointer<16>(&pattr);
437+ break;
438+ case elfcpp::DW_FORM_strx3:
439+ attr_value.val.uintval =
440+ this->dwinfo_->read_3bytes_from_pointer(&pattr);
441+ break;
442+ case elfcpp::DW_FORM_strx4:
443+ attr_value.val.uintval =
444+ this->dwinfo_->read_from_pointer<32>(&pattr);
445+ break;
446 case elfcpp::DW_FORM_sec_offset:
447 {
448 off_t sec_off;
449@@ -747,7 +909,6 @@ Dwarf_die::read_attributes()
450 this->dwinfo_->lookup_reloc(attr_off, &sec_off);
451 attr_value.aux.shndx = shndx;
452 attr_value.val.refval = sec_off;
453- ref_form = true;
454 break;
455 }
456 case elfcpp::DW_FORM_ref_addr:
457@@ -815,6 +976,7 @@ Dwarf_die::read_attributes()
458 break;
459 }
460 case elfcpp::DW_FORM_ref4:
461+ case elfcpp::DW_FORM_ref_sup4:
462 {
463 off_t sec_off;
464 sec_off = this->dwinfo_->read_from_pointer<32>(&pattr);
465@@ -835,11 +997,20 @@ Dwarf_die::read_attributes()
466 attr_value.val.intval = sec_off;
467 break;
468 }
469+ case elfcpp::DW_FORM_data16:
470+ {
471+ // For now, treat this as a 16-byte block.
472+ attr_value.val.blockval = pattr;
473+ attr_value.aux.blocklen = 16;
474+ pattr += 16;
475+ break;
476+ }
477 case elfcpp::DW_FORM_ref_sig8:
478 attr_value.val.uintval =
479 this->dwinfo_->read_from_pointer<64>(&pattr);
480 break;
481 case elfcpp::DW_FORM_ref8:
482+ case elfcpp::DW_FORM_ref_sup8:
483 {
484 off_t sec_off;
485 sec_off = this->dwinfo_->read_from_pointer<64>(&pattr);
486@@ -856,11 +1027,29 @@ Dwarf_die::read_attributes()
487 pattr += len;
488 break;
489 case elfcpp::DW_FORM_udata:
490+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
491+ pattr += len;
492+ break;
493+ case elfcpp::DW_FORM_addrx:
494 case elfcpp::DW_FORM_GNU_addr_index:
495- case elfcpp::DW_FORM_GNU_str_index:
496 attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
497 pattr += len;
498 break;
499+ case elfcpp::DW_FORM_addrx1:
500+ attr_value.val.uintval = *pattr++;
501+ break;
502+ case elfcpp::DW_FORM_addrx2:
503+ attr_value.val.uintval =
504+ this->dwinfo_->read_from_pointer<16>(&pattr);
505+ break;
506+ case elfcpp::DW_FORM_addrx3:
507+ attr_value.val.uintval =
508+ this->dwinfo_->read_3bytes_from_pointer(&pattr);
509+ break;
510+ case elfcpp::DW_FORM_addrx4:
511+ attr_value.val.uintval =
512+ this->dwinfo_->read_from_pointer<32>(&pattr);
513+ break;
514 case elfcpp::DW_FORM_sdata:
515 attr_value.val.intval = read_signed_LEB_128(pattr, &len);
516 pattr += len;
517@@ -870,6 +1059,11 @@ Dwarf_die::read_attributes()
518 len = strlen(attr_value.val.stringval);
519 pattr += len + 1;
520 break;
521+ case elfcpp::DW_FORM_loclistx:
522+ case elfcpp::DW_FORM_rnglistx:
523+ attr_value.val.uintval = read_unsigned_LEB_128(pattr, &len);
524+ pattr += len;
525+ break;
526 default:
527 return false;
528 }
529@@ -954,9 +1148,12 @@ Dwarf_die::skip_attributes()
530 switch(form)
531 {
532 case elfcpp::DW_FORM_flag_present:
533+ case elfcpp::DW_FORM_implicit_const:
534 break;
535 case elfcpp::DW_FORM_strp:
536 case elfcpp::DW_FORM_sec_offset:
537+ case elfcpp::DW_FORM_strp_sup:
538+ case elfcpp::DW_FORM_line_strp:
539 pattr += this->dwinfo_->offset_size();
540 break;
541 case elfcpp::DW_FORM_addr:
542@@ -993,23 +1190,42 @@ Dwarf_die::skip_attributes()
543 case elfcpp::DW_FORM_data1:
544 case elfcpp::DW_FORM_ref1:
545 case elfcpp::DW_FORM_flag:
546+ case elfcpp::DW_FORM_strx1:
547+ case elfcpp::DW_FORM_addrx1:
548 pattr += 1;
549 break;
550 case elfcpp::DW_FORM_data2:
551 case elfcpp::DW_FORM_ref2:
552+ case elfcpp::DW_FORM_strx2:
553+ case elfcpp::DW_FORM_addrx2:
554 pattr += 2;
555 break;
556+ case elfcpp::DW_FORM_strx3:
557+ case elfcpp::DW_FORM_addrx3:
558+ pattr += 3;
559+ break;
560 case elfcpp::DW_FORM_data4:
561 case elfcpp::DW_FORM_ref4:
562+ case elfcpp::DW_FORM_ref_sup4:
563+ case elfcpp::DW_FORM_strx4:
564+ case elfcpp::DW_FORM_addrx4:
565 pattr += 4;
566 break;
567 case elfcpp::DW_FORM_data8:
568 case elfcpp::DW_FORM_ref8:
569 case elfcpp::DW_FORM_ref_sig8:
570+ case elfcpp::DW_FORM_ref_sup8:
571 pattr += 8;
572 break;
573+ case elfcpp::DW_FORM_data16:
574+ pattr += 16;
575+ break;
576 case elfcpp::DW_FORM_ref_udata:
577 case elfcpp::DW_FORM_udata:
578+ case elfcpp::DW_FORM_addrx:
579+ case elfcpp::DW_FORM_strx:
580+ case elfcpp::DW_FORM_loclistx:
581+ case elfcpp::DW_FORM_rnglistx:
582 case elfcpp::DW_FORM_GNU_addr_index:
583 case elfcpp::DW_FORM_GNU_str_index:
584 read_unsigned_LEB_128(pattr, &len);
585@@ -1313,6 +1529,13 @@ Dwarf_info_reader::do_parse()
586 elfcpp::Swap_unaligned<16, big_endian>::readval(pinfo);
587 pinfo += 2;
588
589+ // DWARF 5: Read the unit type (1 byte) and address size (1 byte).
590+ if (this->cu_version_ >= 5)
591+ {
592+ this->unit_type_ = *pinfo++;
593+ this->address_size_ = *pinfo++;
594+ }
595+
596 // Read debug_abbrev_offset (4 or 8 bytes).
597 if (this->offset_size_ == 4)
598 abbrev_offset = elfcpp::Swap_unaligned<32, big_endian>::readval(pinfo);
599@@ -1333,13 +1556,14 @@ Dwarf_info_reader::do_parse()
600 }
601 pinfo += this->offset_size_;
602
603- // Read address_size (1 byte).
604- this->address_size_ = *pinfo++;
605+ // DWARF 2-4: Read address_size (1 byte).
606+ if (this->cu_version_ < 5)
607+ this->address_size_ = *pinfo++;
608
609 // For type units, read the two extra fields.
610 uint64_t signature = 0;
611 off_t type_offset = 0;
612- if (this->is_type_unit_)
613+ if (this->is_type_unit())
614 {
615 if (!this->check_buffer(pinfo + 8 + this->offset_size_))
616 break;
617@@ -1369,7 +1593,7 @@ Dwarf_info_reader::do_parse()
618 if (root_die.tag() != 0)
619 {
620 // Visit the CU or TU.
621- if (this->is_type_unit_)
622+ if (this->is_type_unit())
623 this->visit_type_unit(section_offset + this->cu_offset_,
624 cu_end - cu_start, type_offset, signature,
625 &root_die);
626@@ -1460,6 +1684,19 @@ Dwarf_info_reader::read_from_pointer(const unsigned char** source)
627 return return_value;
628 }
629
630+// Read a 3-byte integer. Update SOURCE after read.
631+inline typename elfcpp::Valtype_base<32>::Valtype
632+Dwarf_info_reader::read_3bytes_from_pointer(const unsigned char** source)
633+{
634+ typename elfcpp::Valtype_base<32>::Valtype return_value;
635+ if (this->object_->is_big_endian())
636+ return_value = ((*source)[0] << 16) | ((*source)[1] << 8) | (*source)[2];
637+ else
638+ return_value = ((*source)[2] << 16) | ((*source)[1] << 8) | (*source)[0];
639+ *source += 3;
640+ return return_value;
641+}
642+
643 // Look for a relocation at offset ATTR_OFF in the dwarf info,
644 // and return the section index and offset of the target.
645
646@@ -1561,27 +1798,40 @@ Sized_dwarf_line_info<size, big_endian>::Sized_dwarf_line_info(
647 Object* object,
648 unsigned int read_shndx)
649 : data_valid_(false), buffer_(NULL), buffer_start_(NULL),
650+ str_buffer_(NULL), str_buffer_start_(NULL),
651 reloc_mapper_(NULL), symtab_buffer_(NULL), directories_(), files_(),
652- current_header_index_(-1)
653+ current_header_index_(-1), reloc_map_(), line_number_map_()
654 {
655- unsigned int debug_shndx;
656+ unsigned int debug_line_shndx = 0;
657+ unsigned int debug_line_str_shndx = 0;
658
659- for (debug_shndx = 1; debug_shndx < object->shnum(); ++debug_shndx)
660+ for (unsigned int i = 1; i < object->shnum(); ++i)
661 {
662+ section_size_type buffer_size;
663+ bool is_new = false;
664+
665 // FIXME: do this more efficiently: section_name() isn't super-fast
666- std::string name = object->section_name(debug_shndx);
667+ std::string name = object->section_name(i);
668 if (name == ".debug_line" || name == ".zdebug_line")
669 {
670- section_size_type buffer_size;
671- bool is_new = false;
672- this->buffer_ = object->decompressed_section_contents(debug_shndx,
673- &buffer_size,
674- &is_new);
675+ this->buffer_ =
676+ object->decompressed_section_contents(i, &buffer_size, &is_new);
677 if (is_new)
678 this->buffer_start_ = this->buffer_;
679 this->buffer_end_ = this->buffer_ + buffer_size;
680- break;
681+ debug_line_shndx = i;
682+ }
683+ else if (name == ".debug_line_str" || name == ".zdebug_line_str")
684+ {
685+ this->str_buffer_ =
686+ object->decompressed_section_contents(i, &buffer_size, &is_new);
687+ if (is_new)
688+ this->str_buffer_start_ = this->str_buffer_;
689+ this->str_buffer_end_ = this->str_buffer_ + buffer_size;
690+ debug_line_str_shndx = i;
691 }
692+ if (debug_line_shndx > 0 && debug_line_str_shndx > 0)
693+ break;
694 }
695 if (this->buffer_ == NULL)
696 return;
697@@ -1594,7 +1844,7 @@ Sized_dwarf_line_info<size, big_endian>::Sized_dwarf_line_info(
698 unsigned int reloc_sh_type = object->section_type(i);
699 if ((reloc_sh_type == elfcpp::SHT_REL
700 || reloc_sh_type == elfcpp::SHT_RELA)
701- && object->section_info(i) == debug_shndx)
702+ && object->section_info(i) == debug_line_shndx)
703 {
704 reloc_shndx = i;
705 this->track_relocs_type_ = reloc_sh_type;
706@@ -1640,65 +1890,80 @@ Sized_dwarf_line_info<size, big_endian>::read_header_prolog(
707 uint32_t initial_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
708 lineptr += 4;
709
710- // In DWARF2/3, if the initial length is all 1 bits, then the offset
711+ // In DWARF, if the initial length is all 1 bits, then the offset
712 // size is 8 and we need to read the next 8 bytes for the real length.
713 if (initial_length == 0xffffffff)
714 {
715- header_.offset_size = 8;
716+ this->header_.offset_size = 8;
717 initial_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
718 lineptr += 8;
719 }
720 else
721- header_.offset_size = 4;
722+ this->header_.offset_size = 4;
723
724- header_.total_length = initial_length;
725+ this->header_.total_length = initial_length;
726
727- gold_assert(lineptr + header_.total_length <= buffer_end_);
728+ this->end_of_unit_ = lineptr + initial_length;
729+ gold_assert(this->end_of_unit_ <= buffer_end_);
730
731- header_.version = elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr);
732+ this->header_.version =
733+ elfcpp::Swap_unaligned<16, big_endian>::readval(lineptr);
734 lineptr += 2;
735
736- // Skip address size and segment selector for DWARF5.
737- if (header_.version >= 5)
738- lineptr += 2;
739+ // We can only read versions 2-5 of the DWARF line number table.
740+ // For other versions, just skip the entire line number table.
741+ if (this->header_.version < 2 || this->header_.version > 5)
742+ return this->end_of_unit_;
743
744- if (header_.offset_size == 4)
745- header_.prologue_length = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
746+ // DWARF 5 only: address size and segment selector.
747+ if (this->header_.version >= 5)
748+ {
749+ this->header_.address_size = *lineptr;
750+ // We ignore the segment selector.
751+ lineptr += 2;
752+ }
753+
754+ if (this->header_.offset_size == 4)
755+ this->header_.prologue_length =
756+ elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
757 else
758- header_.prologue_length = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
759- lineptr += header_.offset_size;
760+ this->header_.prologue_length =
761+ elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
762+ lineptr += this->header_.offset_size;
763
764- header_.min_insn_length = *lineptr;
765+ this->end_of_header_length_ = lineptr;
766+
767+ this->header_.min_insn_length = *lineptr;
768 lineptr += 1;
769
770- if (header_.version < 4)
771- header_.max_ops_per_insn = 1;
772+ if (this->header_.version < 4)
773+ this->header_.max_ops_per_insn = 1;
774 else
775 {
776 // DWARF 4 added the maximum_operations_per_instruction field.
777- header_.max_ops_per_insn = *lineptr;
778+ this->header_.max_ops_per_insn = *lineptr;
779 lineptr += 1;
780 // TODO: Add support for values other than 1.
781- gold_assert(header_.max_ops_per_insn == 1);
782+ gold_assert(this->header_.max_ops_per_insn == 1);
783 }
784
785- header_.default_is_stmt = *lineptr;
786+ this->header_.default_is_stmt = *lineptr;
787 lineptr += 1;
788
789- header_.line_base = *reinterpret_cast<const signed char*>(lineptr);
790+ this->header_.line_base = *reinterpret_cast<const signed char*>(lineptr);
791 lineptr += 1;
792
793- header_.line_range = *lineptr;
794+ this->header_.line_range = *lineptr;
795 lineptr += 1;
796
797- header_.opcode_base = *lineptr;
798+ this->header_.opcode_base = *lineptr;
799 lineptr += 1;
800
801- header_.std_opcode_lengths.resize(header_.opcode_base + 1);
802- header_.std_opcode_lengths[0] = 0;
803- for (int i = 1; i < header_.opcode_base; i++)
804+ this->header_.std_opcode_lengths.resize(this->header_.opcode_base + 1);
805+ this->header_.std_opcode_lengths[0] = 0;
806+ for (int i = 1; i < this->header_.opcode_base; i++)
807 {
808- header_.std_opcode_lengths[i] = *lineptr;
809+ this->header_.std_opcode_lengths[i] = *lineptr;
810 lineptr += 1;
811 }
812
813@@ -1707,10 +1972,11 @@ Sized_dwarf_line_info<size, big_endian>::read_header_prolog(
814
815 // The header for a debug_line section is mildly complicated, because
816 // the line info is very tightly encoded.
817+// This routine is for DWARF versions 2, 3, and 4.
818
819 template<int size, bool big_endian>
820 const unsigned char*
821-Sized_dwarf_line_info<size, big_endian>::read_header_tables(
822+Sized_dwarf_line_info<size, big_endian>::read_header_tables_v2(
823 const unsigned char* lineptr)
824 {
825 ++this->current_header_index_;
826@@ -1775,6 +2041,169 @@ Sized_dwarf_line_info<size, big_endian>::read_header_tables(
827 return lineptr;
828 }
829
830+// This routine is for DWARF version 5.
831+
832+template<int size, bool big_endian>
833+const unsigned char*
834+Sized_dwarf_line_info<size, big_endian>::read_header_tables_v5(
835+ const unsigned char* lineptr)
836+{
837+ size_t len;
838+
839+ ++this->current_header_index_;
840+
841+ gold_assert(static_cast<int>(this->directories_.size())
842+ == this->current_header_index_);
843+ gold_assert(static_cast<int>(this->files_.size())
844+ == this->current_header_index_);
845+
846+ // Read the directory list.
847+ unsigned int format_count = *lineptr;
848+ lineptr += 1;
849+
850+ unsigned int *types = new unsigned int[format_count];
851+ unsigned int *forms = new unsigned int[format_count];
852+
853+ for (unsigned int i = 0; i < format_count; i++)
854+ {
855+ types[i] = read_unsigned_LEB_128(lineptr, &len);
856+ lineptr += len;
857+ forms[i] = read_unsigned_LEB_128(lineptr, &len);
858+ lineptr += len;
859+ }
860+
861+ uint64_t entry_count = read_unsigned_LEB_128(lineptr, &len);
862+ lineptr += len;
863+ this->directories_.push_back(std::vector<std::string>(0));
864+ std::vector<std::string>& dir_list = this->directories_.back();
865+
866+ for (unsigned int j = 0; j < entry_count; j++)
867+ {
868+ std::string dirname;
869+
870+ for (unsigned int i = 0; i < format_count; i++)
871+ {
872+ if (types[i] == elfcpp::DW_LNCT_path)
873+ {
874+ if (forms[i] == elfcpp::DW_FORM_string)
875+ {
876+ dirname = reinterpret_cast<const char*>(lineptr);
877+ lineptr += dirname.size() + 1;
878+ }
879+ else if (forms[i] == elfcpp::DW_FORM_line_strp)
880+ {
881+ uint64_t offset;
882+ if (this->header_.offset_size == 4)
883+ offset =
884+ elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
885+ else
886+ offset =
887+ elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
888+ typename Reloc_map::const_iterator it
889+ = this->reloc_map_.find(lineptr - this->buffer_);
890+ if (it != reloc_map_.end())
891+ {
892+ if (this->track_relocs_type_ == elfcpp::SHT_RELA)
893+ offset = 0;
894+ offset += it->second.second;
895+ }
896+ lineptr += this->header_.offset_size;
897+ dirname = reinterpret_cast<const char*>(this->str_buffer_
898+ + offset);
899+ }
900+ else
901+ return lineptr;
902+ }
903+ else
904+ return lineptr;
905+ }
906+ dir_list.push_back(dirname);
907+ }
908+
909+ delete[] types;
910+ delete[] forms;
911+
912+ // Read the filenames list.
913+ format_count = *lineptr;
914+ lineptr += 1;
915+
916+ types = new unsigned int[format_count];
917+ forms = new unsigned int[format_count];
918+
919+ for (unsigned int i = 0; i < format_count; i++)
920+ {
921+ types[i] = read_unsigned_LEB_128(lineptr, &len);
922+ lineptr += len;
923+ forms[i] = read_unsigned_LEB_128(lineptr, &len);
924+ lineptr += len;
925+ }
926+
927+ entry_count = read_unsigned_LEB_128(lineptr, &len);
928+ lineptr += len;
929+ this->files_.push_back(
930+ std::vector<std::pair<int, std::string> >(0));
931+ std::vector<std::pair<int, std::string> >& file_list = this->files_.back();
932+
933+ for (unsigned int j = 0; j < entry_count; j++)
934+ {
935+ const char* path = NULL;
936+ int dirindex = 0;
937+
938+ for (unsigned int i = 0; i < format_count; i++)
939+ {
940+ if (types[i] == elfcpp::DW_LNCT_path)
941+ {
942+ if (forms[i] == elfcpp::DW_FORM_string)
943+ {
944+ path = reinterpret_cast<const char*>(lineptr);
945+ lineptr += strlen(path) + 1;
946+ }
947+ else if (forms[i] == elfcpp::DW_FORM_line_strp)
948+ {
949+ uint64_t offset;
950+ if (this->header_.offset_size == 4)
951+ offset = elfcpp::Swap_unaligned<32, big_endian>::readval(lineptr);
952+ else
953+ offset = elfcpp::Swap_unaligned<64, big_endian>::readval(lineptr);
954+ typename Reloc_map::const_iterator it
955+ = this->reloc_map_.find(lineptr - this->buffer_);
956+ if (it != reloc_map_.end())
957+ {
958+ if (this->track_relocs_type_ == elfcpp::SHT_RELA)
959+ offset = 0;
960+ offset += it->second.second;
961+ }
962+ lineptr += this->header_.offset_size;
963+ path = reinterpret_cast<const char*>(this->str_buffer_
964+ + offset);
965+ }
966+ else
967+ return lineptr;
968+ }
969+ else if (types[i] == elfcpp::DW_LNCT_directory_index)
970+ {
971+ if (forms[i] == elfcpp::DW_FORM_udata)
972+ {
973+ dirindex = read_unsigned_LEB_128(lineptr, &len);
974+ lineptr += len;
975+ }
976+ else
977+ return lineptr;
978+ }
979+ else
980+ return lineptr;
981+ }
982+ gold_debug(DEBUG_LOCATION, "File %3d: %s",
983+ static_cast<int>(file_list.size()), path);
984+ file_list.push_back(std::make_pair(dirindex, path));
985+ }
986+
987+ delete[] types;
988+ delete[] forms;
989+
990+ return lineptr;
991+}
992+
993 // Process a single opcode in the .debug.line structure.
994
995 template<int size, bool big_endian>
996@@ -1790,15 +2219,15 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
997
998 // If the opcode is great than the opcode_base, it is a special
999 // opcode. Most line programs consist mainly of special opcodes.
1000- if (opcode >= header_.opcode_base)
1001+ if (opcode >= this->header_.opcode_base)
1002 {
1003- opcode -= header_.opcode_base;
1004- const int advance_address = ((opcode / header_.line_range)
1005- * header_.min_insn_length);
1006+ opcode -= this->header_.opcode_base;
1007+ const int advance_address = ((opcode / this->header_.line_range)
1008+ * this->header_.min_insn_length);
1009 lsm->address += advance_address;
1010
1011- const int advance_line = ((opcode % header_.line_range)
1012- + header_.line_base);
1013+ const int advance_line = ((opcode % this->header_.line_range)
1014+ + this->header_.line_base);
1015 lsm->line_num += advance_line;
1016 lsm->basic_block = true;
1017 *len = oplen;
1018@@ -1818,13 +2247,13 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
1019 const uint64_t advance_address
1020 = read_unsigned_LEB_128(start, &templen);
1021 oplen += templen;
1022- lsm->address += header_.min_insn_length * advance_address;
1023+ lsm->address += this->header_.min_insn_length * advance_address;
1024 }
1025 break;
1026
1027 case elfcpp::DW_LNS_advance_line:
1028 {
1029- const uint64_t advance_line = read_signed_LEB_128(start, &templen);
1030+ const int64_t advance_line = read_signed_LEB_128(start, &templen);
1031 oplen += templen;
1032 lsm->line_num += advance_line;
1033 }
1034@@ -1865,9 +2294,9 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
1035
1036 case elfcpp::DW_LNS_const_add_pc:
1037 {
1038- const int advance_address = (header_.min_insn_length
1039- * ((255 - header_.opcode_base)
1040- / header_.line_range));
1041+ const int advance_address = (this->header_.min_insn_length
1042+ * ((255 - this->header_.opcode_base)
1043+ / this->header_.line_range));
1044 lsm->address += advance_address;
1045 }
1046 break;
1047@@ -1950,7 +2379,7 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
1048 default:
1049 {
1050 // Ignore unknown opcode silently
1051- for (int i = 0; i < header_.std_opcode_lengths[opcode]; i++)
1052+ for (int i = 0; i < this->header_.std_opcode_lengths[opcode]; i++)
1053 {
1054 size_t templen;
1055 read_unsigned_LEB_128(start, &templen);
1056@@ -1970,28 +2399,24 @@ Sized_dwarf_line_info<size, big_endian>::process_one_opcode(
1057 template<int size, bool big_endian>
1058 unsigned const char*
1059 Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr,
1060+ unsigned const char* endptr,
1061 unsigned int shndx)
1062 {
1063 struct LineStateMachine lsm;
1064
1065- // LENGTHSTART is the place the length field is based on. It is the
1066- // point in the header after the initial length field.
1067- const unsigned char* lengthstart = buffer_;
1068-
1069- // In 64 bit dwarf, the initial length is 12 bytes, because of the
1070- // 0xffffffff at the start.
1071- if (header_.offset_size == 8)
1072- lengthstart += 12;
1073- else
1074- lengthstart += 4;
1075-
1076- while (lineptr < lengthstart + header_.total_length)
1077+ while (lineptr < endptr)
1078 {
1079- ResetLineStateMachine(&lsm, header_.default_is_stmt);
1080+ ResetLineStateMachine(&lsm, this->header_.default_is_stmt);
1081 while (!lsm.end_sequence)
1082 {
1083 size_t oplength;
1084+
1085+ if (lineptr >= endptr)
1086+ break;
1087+
1088 bool add_line = this->process_one_opcode(lineptr, &lsm, &oplength);
1089+ lineptr += oplength;
1090+
1091 if (add_line
1092 && (shndx == -1U || lsm.shndx == -1U || shndx == lsm.shndx))
1093 {
1094@@ -2012,11 +2437,10 @@ Sized_dwarf_line_info<size, big_endian>::read_lines(unsigned const char* lineptr
1095 map.back().last_line_for_offset = false;
1096 map.push_back(entry);
1097 }
1098- lineptr += oplength;
1099 }
1100 }
1101
1102- return lengthstart + header_.total_length;
1103+ return endptr;
1104 }
1105
1106 // Read the relocations into a Reloc_map.
1107@@ -2057,9 +2481,17 @@ Sized_dwarf_line_info<size, big_endian>::read_line_mappings(unsigned int shndx)
1108 {
1109 const unsigned char* lineptr = this->buffer_;
1110 lineptr = this->read_header_prolog(lineptr);
1111- lineptr = this->read_header_tables(lineptr);
1112- lineptr = this->read_lines(lineptr, shndx);
1113- this->buffer_ = lineptr;
1114+ if (this->header_.version >= 2 && this->header_.version <= 4)
1115+ {
1116+ lineptr = this->read_header_tables_v2(lineptr);
1117+ lineptr = this->read_lines(lineptr, this->end_of_unit_, shndx);
1118+ }
1119+ else if (this->header_.version == 5)
1120+ {
1121+ lineptr = this->read_header_tables_v5(lineptr);
1122+ lineptr = this->read_lines(lineptr, this->end_of_unit_, shndx);
1123+ }
1124+ this->buffer_ = this->end_of_unit_;
1125 }
1126
1127 // Sort the lines numbers, so addr2line can use binary search.
1128@@ -2215,6 +2647,9 @@ Sized_dwarf_line_info<size, big_endian>::do_addr2line(
1129 off_t offset,
1130 std::vector<std::string>* other_lines)
1131 {
1132+ gold_debug(DEBUG_LOCATION, "do_addr2line: shndx %u offset %08x",
1133+ shndx, static_cast<int>(offset));
1134+
1135 if (this->data_valid_ == false)
1136 return "";
1137
1138diff --git a/gold/dwarf_reader.h b/gold/dwarf_reader.h
1139index 80b2231327c..921a1f7c876 100644
1140--- a/gold/dwarf_reader.h
1141+++ b/gold/dwarf_reader.h
1142@@ -173,11 +173,12 @@ class Dwarf_abbrev_table
1143 // An attribute list entry.
1144 struct Attribute
1145 {
1146- Attribute(unsigned int a, unsigned int f)
1147- : attr(a), form(f)
1148+ Attribute(unsigned int a, unsigned int f, int c)
1149+ : attr(a), form(f), implicit_const(c)
1150 { }
1151 unsigned int attr;
1152 unsigned int form;
1153+ int implicit_const;
1154 };
1155
1156 // An abbrev code entry.
1157@@ -190,9 +191,9 @@ class Dwarf_abbrev_table
1158 }
1159
1160 void
1161- add_attribute(unsigned int attr, unsigned int form)
1162+ add_attribute(unsigned int attr, unsigned int form, int implicit_const)
1163 {
1164- this->attributes.push_back(Attribute(attr, form));
1165+ this->attributes.push_back(Attribute(attr, form, implicit_const));
1166 }
1167
1168 // The DWARF tag.
1169@@ -349,14 +350,15 @@ class Dwarf_ranges_table
1170 delete this->ranges_reloc_mapper_;
1171 }
1172
1173- // Read the ranges table from an object file.
1174+ // Fetch the contents of the ranges table from an object file.
1175 bool
1176 read_ranges_table(Relobj* object,
1177 const unsigned char* symtab,
1178 off_t symtab_size,
1179- unsigned int ranges_shndx);
1180+ unsigned int ranges_shndx,
1181+ unsigned int version);
1182
1183- // Read the range table from an object file.
1184+ // Read the DWARF 2/3/4 range table.
1185 Dwarf_range_list*
1186 read_range_list(Relobj* object,
1187 const unsigned char* symtab,
1188@@ -365,6 +367,15 @@ class Dwarf_ranges_table
1189 unsigned int ranges_shndx,
1190 off_t ranges_offset);
1191
1192+ // Read the DWARF 5 rnglists table.
1193+ Dwarf_range_list*
1194+ read_range_list_v5(Relobj* object,
1195+ const unsigned char* symtab,
1196+ off_t symtab_size,
1197+ unsigned int address_size,
1198+ unsigned int ranges_shndx,
1199+ off_t ranges_offset);
1200+
1201 // Look for a relocation at offset OFF in the range table,
1202 // and return the section index and offset of the target.
1203 unsigned int
1204@@ -490,8 +501,6 @@ class Dwarf_die
1205 unsigned int shndx;
1206 // Block length for block forms.
1207 unsigned int blocklen;
1208- // Attribute offset for DW_FORM_strp.
1209- unsigned int attr_off;
1210 } aux;
1211 };
1212
1213@@ -684,6 +693,10 @@ class Dwarf_die
1214 // calls the various visit_xxx() methods for each header. Clients
1215 // should derive a new class from this one and implement the
1216 // visit_compilation_unit() and visit_type_unit() functions.
1217+// IS_TYPE_UNIT is true if we are reading from a .debug_types section,
1218+// which is used only in DWARF 4. For DWARF 5, it will be false,
1219+// and we will determine whether it's a type init when we parse the
1220+// header.
1221
1222 class Dwarf_info_reader
1223 {
1224@@ -695,7 +708,7 @@ class Dwarf_info_reader
1225 unsigned int shndx,
1226 unsigned int reloc_shndx,
1227 unsigned int reloc_type)
1228- : is_type_unit_(is_type_unit), object_(object), symtab_(symtab),
1229+ : object_(object), symtab_(symtab),
1230 symtab_size_(symtab_size), shndx_(shndx), reloc_shndx_(reloc_shndx),
1231 reloc_type_(reloc_type), abbrev_shndx_(0), string_shndx_(0),
1232 buffer_(NULL), buffer_end_(NULL), cu_offset_(0), cu_length_(0),
1233@@ -703,7 +716,12 @@ class Dwarf_info_reader
1234 abbrev_table_(), ranges_table_(this),
1235 reloc_mapper_(NULL), string_buffer_(NULL), string_buffer_end_(NULL),
1236 owns_string_buffer_(false), string_output_section_offset_(0)
1237- { }
1238+ {
1239+ // For DWARF 4, we infer the unit type from the section name.
1240+ // For DWARF 5, we will read this from the unit header.
1241+ this->unit_type_ =
1242+ (is_type_unit ? elfcpp::DW_UT_type : elfcpp::DW_UT_compile);
1243+ }
1244
1245 virtual
1246 ~Dwarf_info_reader()
1247@@ -714,6 +732,13 @@ class Dwarf_info_reader
1248 delete[] this->string_buffer_;
1249 }
1250
1251+ bool
1252+ is_type_unit() const
1253+ {
1254+ return (this->unit_type_ == elfcpp::DW_UT_type
1255+ || this->unit_type_ == elfcpp::DW_UT_split_type);
1256+ }
1257+
1258 // Begin parsing the debug info. This calls visit_compilation_unit()
1259 // or visit_type_unit() for each compilation or type unit found in the
1260 // section, and visit_die() for each top-level DIE.
1261@@ -745,6 +770,9 @@ class Dwarf_info_reader
1262 inline typename elfcpp::Valtype_base<valsize>::Valtype
1263 read_from_pointer(const unsigned char** source);
1264
1265+ inline typename elfcpp::Valtype_base<32>::Valtype
1266+ read_3bytes_from_pointer(const unsigned char** source);
1267+
1268 // Look for a relocation at offset ATTR_OFF in the dwarf info,
1269 // and return the section index and offset of the target.
1270 unsigned int
1271@@ -818,12 +846,20 @@ class Dwarf_info_reader
1272 Dwarf_range_list*
1273 read_range_list(unsigned int ranges_shndx, off_t ranges_offset)
1274 {
1275- return this->ranges_table_.read_range_list(this->object_,
1276- this->symtab_,
1277- this->symtab_size_,
1278- this->address_size_,
1279- ranges_shndx,
1280- ranges_offset);
1281+ if (this->cu_version_ < 5)
1282+ return this->ranges_table_.read_range_list(this->object_,
1283+ this->symtab_,
1284+ this->symtab_size_,
1285+ this->address_size_,
1286+ ranges_shndx,
1287+ ranges_offset);
1288+ else
1289+ return this->ranges_table_.read_range_list_v5(this->object_,
1290+ this->symtab_,
1291+ this->symtab_size_,
1292+ this->address_size_,
1293+ ranges_shndx,
1294+ ranges_offset);
1295 }
1296
1297 // Return the object.
1298@@ -873,8 +909,8 @@ class Dwarf_info_reader
1299 bool
1300 do_read_string_table(unsigned int string_shndx);
1301
1302- // True if this is a type unit; false for a compilation unit.
1303- bool is_type_unit_;
1304+ // The unit type (DW_UT_xxx).
1305+ unsigned int unit_type_;
1306 // The object containing the .debug_info or .debug_types input section.
1307 Relobj* object_;
1308 // The ELF symbol table.
1309@@ -1008,6 +1044,8 @@ class Sized_dwarf_line_info : public Dwarf_line_info
1310 {
1311 if (this->buffer_start_ != NULL)
1312 delete[] this->buffer_start_;
1313+ if (this->str_buffer_start_ != NULL)
1314+ delete[] this->str_buffer_start_;
1315 }
1316
1317 private:
1318@@ -1030,19 +1068,23 @@ class Sized_dwarf_line_info : public Dwarf_line_info
1319 void
1320 read_relocs();
1321
1322- // Reads the DWARF2/3 header for this line info. Each takes as input
1323+ // Reads the DWARF header for this line info. Each takes as input
1324 // a starting buffer position, and returns the ending position.
1325 const unsigned char*
1326 read_header_prolog(const unsigned char* lineptr);
1327
1328 const unsigned char*
1329- read_header_tables(const unsigned char* lineptr);
1330+ read_header_tables_v2(const unsigned char* lineptr);
1331+
1332+ const unsigned char*
1333+ read_header_tables_v5(const unsigned char* lineptr);
1334
1335- // Reads the DWARF2/3 line information. If shndx is non-negative,
1336+ // Reads the DWARF line information. If shndx is non-negative,
1337 // discard all line information that doesn't pertain to the given
1338 // section.
1339 const unsigned char*
1340- read_lines(const unsigned char* lineptr, unsigned int shndx);
1341+ read_lines(const unsigned char* lineptr, const unsigned char* endptr,
1342+ unsigned int shndx);
1343
1344 // Process a single line info opcode at START using the state
1345 // machine at LSM. Return true if we should define a line using the
1346@@ -1069,6 +1111,7 @@ class Sized_dwarf_line_info : public Dwarf_line_info
1347 {
1348 off_t total_length;
1349 int version;
1350+ int address_size;
1351 off_t prologue_length;
1352 int min_insn_length; // insn stands for instruction
1353 int max_ops_per_insn; // Added in DWARF-4.
1354@@ -1089,6 +1132,20 @@ class Sized_dwarf_line_info : public Dwarf_line_info
1355 // of the buffer.
1356 const unsigned char* buffer_start_;
1357
1358+ // str_buffer is the buffer for the line table strings.
1359+ const unsigned char* str_buffer_;
1360+ const unsigned char* str_buffer_end_;
1361+ // If the buffer was allocated temporarily, and therefore must be
1362+ // deallocated in the dtor, this contains a pointer to the start
1363+ // of the buffer.
1364+ const unsigned char* str_buffer_start_;
1365+
1366+ // Pointer to the end of the header_length field (aka prologue_length).
1367+ const unsigned char* end_of_header_length_;
1368+
1369+ // Pointer to the end of the current compilation unit.
1370+ const unsigned char* end_of_unit_;
1371+
1372 // This has relocations that point into buffer.
1373 Sized_elf_reloc_mapper<size, big_endian>* reloc_mapper_;
1374 // The type of the reloc section in track_relocs_--SHT_REL or SHT_RELA.
generated by cgit v1.2.3-54-g00ecf (git 2.39.0) at 2026-05-29 23:21:28 +0000