Skip to content

Commit 38c185e

Browse files
philipcphilipc
authored
Delete support for segment selectors (gimli-rs#720)
segment selectors are deprecated in DWARF6, and we already don't properly support them in some other sections. https://dwarfstd.org/issues/220427.1.html This will simplify adding support for different address types.
1 parent 345d60f commit 38c185e

File tree

5 files changed

+31
-249
lines changed

5 files changed

+31
-249
lines changed

‎crates/examples/src/bin/dwarfdump.rs‎

Lines changed: 2 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -2162,25 +2162,16 @@ fn dump_aranges<R: Reader, W: Write>(
21622162
while let Some(header) = headers.next()? {
21632163
writeln!(
21642164
w,
2165-
"Address Range Header: length = 0x{:08x}, version = 0x{:04x}, cu_offset = 0x{:08x}, addr_size = 0x{:02x}, seg_size = 0x{:02x}",
2165+
"Address Range Header: length = 0x{:08x}, version = 0x{:04x}, cu_offset = 0x{:08x}, addr_size = 0x{:02x}",
21662166
header.length(),
21672167
header.encoding().version,
21682168
header.debug_info_offset().0,
21692169
header.encoding().address_size,
2170-
header.segment_size(),
21712170
)?;
21722171
let mut aranges = header.entries();
21732172
while let Some(arange) = aranges.next()? {
21742173
let range = arange.range();
2175-
if let Some(segment) = arange.segment() {
2176-
writeln!(
2177-
w,
2178-
"[0x{:016x}, 0x{:016x}) segment 0x{:x}",
2179-
range.begin, range.end, segment
2180-
)?;
2181-
} else {
2182-
writeln!(w, "[0x{:016x}, 0x{:016x})", range.begin, range.end)?;
2183-
}
2174+
writeln!(w, "[0x{:016x}, 0x{:016x})", range.begin, range.end)?;
21842175
}
21852176
}
21862177
Ok(())

‎src/common.rs‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -48,8 +48,6 @@ pub struct Encoding {
4848
/// The size of an address.
4949
pub address_size: u8,
5050

51-
// The size of a segment selector.
52-
// TODO: pub segment_size: u8,
5351
/// Whether the DWARF format is 32- or 64-bit.
5452
pub format: Format,
5553

‎src/read/aranges.rs‎

Lines changed: 20 additions & 98 deletions
Original file line numberDiff line numberDiff line change
@@ -135,7 +135,6 @@ where
135135
encoding: Encoding,
136136
length: Offset,
137137
debug_info_offset: DebugInfoOffset<Offset>,
138-
segment_size: u8,
139138
entries: R,
140139
}
141140

@@ -160,16 +159,17 @@ where
160159
let debug_info_offset = rest.read_offset(format).map(DebugInfoOffset)?;
161160
let address_size = rest.read_u8()?;
162161
let segment_size = rest.read_u8()?;
162+
if segment_size != 0 {
163+
return Err(Error::UnsupportedSegmentSize);
164+
}
163165

164166
// unit_length + version + offset + address_size + segment_size
165167
let header_length = format.initial_length_size() + 2 + format.word_size() + 1 + 1;
166168

167169
// The first tuple following the header in each set begins at an offset that is
168-
// a multiple of the size of a single tuple (that is, the size of a segment selector
169-
// plus twice the size of an address).
170+
// a multiple of the size of a single tuple (that is, twice the size of an address).
170171
let tuple_length = address_size
171172
.checked_mul(2)
172-
.and_then(|x| x.checked_add(segment_size))
173173
.ok_or(Error::InvalidAddressRange)?;
174174
if tuple_length == 0 {
175175
return Err(Error::InvalidAddressRange);
@@ -185,14 +185,12 @@ where
185185
format,
186186
version,
187187
address_size,
188-
// TODO: segment_size
189188
};
190189
Ok(ArangeHeader {
191190
offset,
192191
encoding,
193192
length,
194193
debug_info_offset,
195-
segment_size,
196194
entries: rest,
197195
})
198196
}
@@ -215,12 +213,6 @@ where
215213
self.encoding
216214
}
217215

218-
/// Return the segment size for this set of entries.
219-
#[inline]
220-
pub fn segment_size(&self) -> u8 {
221-
self.segment_size
222-
}
223-
224216
/// Return the offset into the .debug_info section for this set of arange entries.
225217
#[inline]
226218
pub fn debug_info_offset(&self) -> DebugInfoOffset<Offset> {
@@ -233,7 +225,6 @@ where
233225
ArangeEntryIter {
234226
input: self.entries.clone(),
235227
encoding: self.encoding,
236-
segment_size: self.segment_size,
237228
}
238229
}
239230
}
@@ -246,7 +237,6 @@ where
246237
pub struct ArangeEntryIter<R: Reader> {
247238
input: R,
248239
encoding: Encoding,
249-
segment_size: u8,
250240
}
251241

252242
impl<R: Reader> ArangeEntryIter<R> {
@@ -261,7 +251,7 @@ impl<R: Reader> ArangeEntryIter<R> {
261251
return Ok(None);
262252
}
263253

264-
match ArangeEntry::parse(&mut self.input, self.encoding, self.segment_size) {
254+
match ArangeEntry::parse(&mut self.input, self.encoding) {
265255
Ok(Some(entry)) => Ok(Some(entry)),
266256
Ok(None) => {
267257
self.input.empty();
@@ -288,60 +278,37 @@ impl<R: Reader> fallible_iterator::FallibleIterator for ArangeEntryIter<R> {
288278
/// A single parsed arange.
289279
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
290280
pub struct ArangeEntry {
291-
segment: Option<u64>,
292281
range: Range,
293282
length: u64,
294283
}
295284

296285
impl ArangeEntry {
297286
/// Parse a single arange. Return `None` for the null arange, `Some` for an actual arange.
298-
fn parse<R: Reader>(
299-
input: &mut R,
300-
encoding: Encoding,
301-
segment_size: u8,
302-
) -> Result<Option<Self>> {
287+
fn parse<R: Reader>(input: &mut R, encoding: Encoding) -> Result<Option<Self>> {
303288
let address_size = encoding.address_size;
304289

305-
let tuple_length = R::Offset::from_u8(2 * address_size + segment_size);
290+
let tuple_length = R::Offset::from_u8(2 * address_size);
306291
if tuple_length > input.len() {
307292
input.empty();
308293
return Ok(None);
309294
}
310295

311-
let segment = if segment_size != 0 {
312-
input.read_address(segment_size)?
313-
} else {
314-
0
315-
};
316296
let begin = input.read_address(address_size)?;
317297
let length = input.read_address(address_size)?;
318298
// Calculate end now so that we can handle overflow.
319299
// TODO: handle 32-bit address overflow as well.
320300
let end = begin.checked_add(length).ok_or(Error::AddressOverflow)?;
301+
let range = Range { begin, end };
321302

322-
match (segment, begin, length) {
303+
match (begin, length) {
323304
// This is meant to be a null terminator, but in practice it can occur
324305
// before the end, possibly due to a linker omitting a function and
325306
// leaving an unrelocated entry.
326-
(0, 0, 0) => Self::parse(input, encoding, segment_size),
327-
_ => Ok(Some(ArangeEntry {
328-
segment: if segment_size != 0 {
329-
Some(segment)
330-
} else {
331-
None
332-
},
333-
range: Range { begin, end },
334-
length,
335-
})),
307+
(0, 0) => Self::parse(input, encoding),
308+
_ => Ok(Some(ArangeEntry { range, length })),
336309
}
337310
}
338311

339-
/// Return the segment selector of this arange.
340-
#[inline]
341-
pub fn segment(&self) -> Option<u64> {
342-
self.segment
343-
}
344-
345312
/// Return the beginning address of this arange.
346313
#[inline]
347314
pub fn address(&self) -> u64 {
@@ -426,20 +393,19 @@ mod tests {
426393
fn test_parse_header_ok() {
427394
#[rustfmt::skip]
428395
let buf = [
429-
// 32-bit length = 32.
430-
0x20, 0x00, 0x00, 0x00,
396+
// 32-bit length = 28 (8 bytes header, 4 bytes padding, 16 bytes tuple data).
397+
0x1c, 0x00, 0x00, 0x00,
431398
// Version.
432399
0x02, 0x00,
433400
// Offset.
434401
0x01, 0x02, 0x03, 0x04,
435402
// Address size.
436403
0x08,
437404
// Segment size.
438-
0x04,
439-
// Length to here = 12, tuple length = 20.
405+
0x00,
406+
// Length to here = 12, tuple length = 16.
440407
// Padding to tuple length multiple = 4.
441408
0x10, 0x00, 0x00, 0x00,
442-
0x00, 0x00, 0x00, 0x00,
443409

444410
// Dummy arange tuple data.
445411
0x20, 0x00, 0x00, 0x00,
@@ -472,9 +438,8 @@ mod tests {
472438
version: 2,
473439
address_size: 8,
474440
},
475-
length: 0x20,
441+
length: 0x1c,
476442
debug_info_offset: DebugInfoOffset(0x0403_0201),
477-
segment_size: 4,
478443
entries: EndianSlice::new(&buf[buf.len() - 32..buf.len() - 16], LittleEndian),
479444
}
480445
);
@@ -493,7 +458,7 @@ mod tests {
493458
// Address size.
494459
0xff,
495460
// Segment size.
496-
0xff,
461+
0x00,
497462
// Length to here = 12, tuple length = 20.
498463
// Padding to tuple length multiple = 4.
499464
0x10, 0x00, 0x00, 0x00,
@@ -566,52 +531,13 @@ mod tests {
566531
version: 2,
567532
address_size: 4,
568533
};
569-
let segment_size = 0;
570534
let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09];
571535
let rest = &mut EndianSlice::new(&buf, LittleEndian);
572-
let entry =
573-
ArangeEntry::parse(rest, encoding, segment_size).expect("should parse entry ok");
574-
assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
575-
assert_eq!(
576-
entry,
577-
Some(ArangeEntry {
578-
segment: None,
579-
range: Range {
580-
begin: 0x0403_0201,
581-
end: 0x0403_0201 + 0x0807_0605,
582-
},
583-
length: 0x0807_0605,
584-
})
585-
);
586-
}
587-
588-
#[test]
589-
fn test_parse_entry_segment() {
590-
let encoding = Encoding {
591-
format: Format::Dwarf32,
592-
version: 2,
593-
address_size: 4,
594-
};
595-
let segment_size = 8;
596-
#[rustfmt::skip]
597-
let buf = [
598-
// Segment.
599-
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
600-
// Address.
601-
0x01, 0x02, 0x03, 0x04,
602-
// Length.
603-
0x05, 0x06, 0x07, 0x08,
604-
// Next tuple.
605-
0x09
606-
];
607-
let rest = &mut EndianSlice::new(&buf, LittleEndian);
608-
let entry =
609-
ArangeEntry::parse(rest, encoding, segment_size).expect("should parse entry ok");
536+
let entry = ArangeEntry::parse(rest, encoding).expect("should parse entry ok");
610537
assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
611538
assert_eq!(
612539
entry,
613540
Some(ArangeEntry {
614-
segment: Some(0x1817_1615_1413_1211),
615541
range: Range {
616542
begin: 0x0403_0201,
617543
end: 0x0403_0201 + 0x0807_0605,
@@ -628,7 +554,6 @@ mod tests {
628554
version: 2,
629555
address_size: 4,
630556
};
631-
let segment_size = 0;
632557
#[rustfmt::skip]
633558
let buf = [
634559
// Zero tuple.
@@ -641,13 +566,11 @@ mod tests {
641566
0x09
642567
];
643568
let rest = &mut EndianSlice::new(&buf, LittleEndian);
644-
let entry =
645-
ArangeEntry::parse(rest, encoding, segment_size).expect("should parse entry ok");
569+
let entry = ArangeEntry::parse(rest, encoding).expect("should parse entry ok");
646570
assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
647571
assert_eq!(
648572
entry,
649573
Some(ArangeEntry {
650-
segment: None,
651574
range: Range {
652575
begin: 0x0403_0201,
653576
end: 0x0403_0201 + 0x0807_0605,
@@ -664,7 +587,6 @@ mod tests {
664587
version: 2,
665588
address_size: 8,
666589
};
667-
let segment_size = 0;
668590
#[rustfmt::skip]
669591
let buf = [
670592
// Address.
@@ -675,7 +597,7 @@ mod tests {
675597
0x09
676598
];
677599
let rest = &mut EndianSlice::new(&buf, LittleEndian);
678-
let entry = ArangeEntry::parse(rest, encoding, segment_size);
600+
let entry = ArangeEntry::parse(rest, encoding);
679601
assert_eq!(*rest, EndianSlice::new(&buf[buf.len() - 1..], LittleEndian));
680602
assert_eq!(entry, Err(Error::AddressOverflow));
681603
}

0 commit comments

Comments
 (0)