Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit a5ee5cb

Browse files
committed
Auto merge of #128330 - matthiaskrgr:rollup-auairjd, r=matthiaskrgr
Rollup of 5 pull requests Successful merges: - #109174 (Replace `io::Cursor::{remaining_slice, is_empty}`) - #127290 (Fully document `rustdoc-json-types`) - #128055 (std: unsafe-wrap personality::dwarf::eh) - #128269 (improve cargo invocations on bootstrap) - #128310 (Add missing periods on `BTreeMap` cursor `peek_next` docs) Failed merges: - #127543 (More unsafe attr verification) - #128182 (handle no_std targets on std builds) r? `@ghost` `@rustbot` modify labels: rollup
2 parents 2e63026 + 0c6d2fb commit a5ee5cb

File tree

15 files changed

+785
-257
lines changed

15 files changed

+785
-257
lines changed

‎library/alloc/src/collections/btree/map.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2921,7 +2921,7 @@ impl<'a, K, V> Cursor<'a, K, V> {
29212921
/// Returns a reference to the key and value of the next element without
29222922
/// moving the cursor.
29232923
///
2924-
/// If the cursor is at the end of the map then `None` is returned
2924+
/// If the cursor is at the end of the map then `None` is returned.
29252925
#[unstable(feature = "btree_cursors", issue = "107540")]
29262926
pub fn peek_next(&self) -> Option<(&'a K, &'a V)> {
29272927
self.clone().next()
@@ -2963,7 +2963,7 @@ impl<'a, K, V, A> CursorMut<'a, K, V, A> {
29632963
/// Returns a reference to the key and value of the next element without
29642964
/// moving the cursor.
29652965
///
2966-
/// If the cursor is at the end of the map then `None` is returned
2966+
/// If the cursor is at the end of the map then `None` is returned.
29672967
#[unstable(feature = "btree_cursors", issue = "107540")]
29682968
pub fn peek_next(&mut self) -> Option<(&K, &mut V)> {
29692969
let (k, v) = self.inner.peek_next()?;
@@ -3061,7 +3061,7 @@ impl<'a, K, V, A> CursorMutKey<'a, K, V, A> {
30613061
/// Returns a reference to the key and value of the next element without
30623062
/// moving the cursor.
30633063
///
3064-
/// If the cursor is at the end of the map then `None` is returned
3064+
/// If the cursor is at the end of the map then `None` is returned.
30653065
#[unstable(feature = "btree_cursors", issue = "107540")]
30663066
pub fn peek_next(&mut self) -> Option<(&mut K, &mut V)> {
30673067
let current = self.current.as_mut()?;

‎library/std/src/io/cursor.rs‎

Lines changed: 35 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -209,55 +209,60 @@ impl<T> Cursor<T>
209209
where
210210
T: AsRef<[u8]>,
211211
{
212-
/// Returns the remaining slice.
212+
/// Splits the underlying slice at the cursor position and returns them.
213213
///
214214
/// # Examples
215215
///
216216
/// ```
217-
/// #![feature(cursor_remaining)]
217+
/// #![feature(cursor_split)]
218218
/// use std::io::Cursor;
219219
///
220220
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
221221
///
222-
/// assert_eq!(buff.remaining_slice(), &[1, 2, 3, 4, 5]);
222+
/// assert_eq!(buff.split(), ([].as_slice(), [1, 2, 3, 4, 5].as_slice()));
223223
///
224224
/// buff.set_position(2);
225-
/// assert_eq!(buff.remaining_slice(), &[3, 4, 5]);
226-
///
227-
/// buff.set_position(4);
228-
/// assert_eq!(buff.remaining_slice(), &[5]);
225+
/// assert_eq!(buff.split(), ([1, 2].as_slice(), [3, 4, 5].as_slice()));
229226
///
230227
/// buff.set_position(6);
231-
/// assert_eq!(buff.remaining_slice(), &[]);
228+
/// assert_eq!(buff.split(), ([1, 2, 3, 4, 5].as_slice(), [].as_slice()));
232229
/// ```
233-
#[unstable(feature = "cursor_remaining", issue = "86369")]
234-
pub fn remaining_slice(&self) -> &[u8] {
235-
let len = self.pos.min(self.inner.as_ref().len() as u64);
236-
&self.inner.as_ref()[(len as usize)..]
230+
#[unstable(feature = "cursor_split", issue = "86369")]
231+
pub fn split(&self) -> (&[u8], &[u8]) {
232+
let slice = self.inner.as_ref();
233+
let pos = self.pos.min(slice.len() as u64);
234+
slice.split_at(pos as usize)
237235
}
236+
}
238237

239-
/// Returns `true` if the remaining slice is empty.
238+
impl<T> Cursor<T>
239+
where
240+
T: AsMut<[u8]>,
241+
{
242+
/// Splits the underlying slice at the cursor position and returns them
243+
/// mutably.
240244
///
241245
/// # Examples
242246
///
243247
/// ```
244-
/// #![feature(cursor_remaining)]
248+
/// #![feature(cursor_split)]
245249
/// use std::io::Cursor;
246250
///
247251
/// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);
248252
///
249-
/// buff.set_position(2);
250-
/// assert!(!buff.is_empty());
253+
/// assert_eq!(buff.split_mut(), ([].as_mut_slice(), [1, 2, 3, 4, 5].as_mut_slice()));
251254
///
252-
/// buff.set_position(5);
253-
/// assert!(buff.is_empty());
255+
/// buff.set_position(2);
256+
/// assert_eq!(buff.split_mut(), ([1, 2].as_mut_slice(), [3, 4, 5].as_mut_slice()));
254257
///
255-
/// buff.set_position(10);
256-
/// assert!(buff.is_empty());
258+
/// buff.set_position(6);
259+
/// assert_eq!(buff.split_mut(), ([1, 2, 3, 4, 5].as_mut_slice(), [].as_mut_slice()));
257260
/// ```
258-
#[unstable(feature = "cursor_remaining", issue = "86369")]
259-
pub fn is_empty(&self) -> bool {
260-
self.pos >= self.inner.as_ref().len() as u64
261+
#[unstable(feature = "cursor_split", issue = "86369")]
262+
pub fn split_mut(&mut self) -> (&mut [u8], &mut [u8]) {
263+
let slice = self.inner.as_mut();
264+
let pos = self.pos.min(slice.len() as u64);
265+
slice.split_at_mut(pos as usize)
261266
}
262267
}
263268

@@ -319,15 +324,15 @@ where
319324
T: AsRef<[u8]>,
320325
{
321326
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
322-
let n = Read::read(&mut self.remaining_slice(), buf)?;
327+
let n = Read::read(&mut Cursor::split(self).1, buf)?;
323328
self.pos += n as u64;
324329
Ok(n)
325330
}
326331

327332
fn read_buf(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
328333
let prev_written = cursor.written();
329334

330-
Read::read_buf(&mut self.remaining_slice(), cursor.reborrow())?;
335+
Read::read_buf(&mut Cursor::split(self).1, cursor.reborrow())?;
331336

332337
self.pos += (cursor.written() - prev_written) as u64;
333338

@@ -351,7 +356,7 @@ where
351356
}
352357

353358
fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
354-
let result = Read::read_exact(&mut self.remaining_slice(), buf);
359+
let result = Read::read_exact(&mut Cursor::split(self).1, buf);
355360

356361
match result {
357362
Ok(_) => self.pos += buf.len() as u64,
@@ -365,14 +370,14 @@ where
365370
fn read_buf_exact(&mut self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
366371
let prev_written = cursor.written();
367372

368-
let result = Read::read_buf_exact(&mut self.remaining_slice(), cursor.reborrow());
373+
let result = Read::read_buf_exact(&mut Cursor::split(self).1, cursor.reborrow());
369374
self.pos += (cursor.written() - prev_written) as u64;
370375

371376
result
372377
}
373378

374379
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {
375-
let content = self.remaining_slice();
380+
let content = Cursor::split(self).1;
376381
let len = content.len();
377382
buf.try_reserve(len)?;
378383
buf.extend_from_slice(content);
@@ -383,7 +388,7 @@ where
383388

384389
fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {
385390
let content =
386-
crate::str::from_utf8(self.remaining_slice()).map_err(|_| io::Error::INVALID_UTF8)?;
391+
crate::str::from_utf8(Cursor::split(self).1).map_err(|_| io::Error::INVALID_UTF8)?;
387392
let len = content.len();
388393
buf.try_reserve(len)?;
389394
buf.push_str(content);
@@ -399,7 +404,7 @@ where
399404
T: AsRef<[u8]>,
400405
{
401406
fn fill_buf(&mut self) -> io::Result<&[u8]> {
402-
Ok(self.remaining_slice())
407+
Ok(Cursor::split(self).1)
403408
}
404409
fn consume(&mut self, amt: usize) {
405410
self.pos += amt as u64;

‎library/std/src/io/tests.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -676,13 +676,13 @@ fn cursor_read_exact_eof() {
676676

677677
let mut r = slice.clone();
678678
assert!(r.read_exact(&mut [0; 10]).is_err());
679-
assert!(r.is_empty());
679+
assert!(Cursor::split(&r).1.is_empty());
680680

681681
let mut r = slice;
682682
let buf = &mut [0; 10];
683683
let mut buf = BorrowedBuf::from(buf.as_mut_slice());
684684
assert!(r.read_buf_exact(buf.unfilled()).is_err());
685-
assert!(r.is_empty());
685+
assert!(Cursor::split(&r).1.is_empty());
686686
assert_eq!(buf.filled(), b"123456");
687687
}
688688

‎library/std/src/sys/personality/dwarf/eh.rs‎

Lines changed: 60 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -70,45 +70,51 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result
7070

7171
let func_start = context.func_start;
7272
let mut reader = DwarfReader::new(lsda);
73-
74-
let start_encoding = reader.read::<u8>();
75-
// base address for landing pad offsets
76-
let lpad_base = if start_encoding != DW_EH_PE_omit {
77-
read_encoded_pointer(&mut reader, context, start_encoding)?
78-
} else {
79-
func_start
73+
let lpad_base = unsafe {
74+
let start_encoding = reader.read::<u8>();
75+
// base address for landing pad offsets
76+
if start_encoding != DW_EH_PE_omit {
77+
read_encoded_pointer(&mut reader, context, start_encoding)?
78+
} else {
79+
func_start
80+
}
8081
};
82+
let call_site_encoding = unsafe {
83+
let ttype_encoding = reader.read::<u8>();
84+
if ttype_encoding != DW_EH_PE_omit {
85+
// Rust doesn't analyze exception types, so we don't care about the type table
86+
reader.read_uleb128();
87+
}
8188

82-
let ttype_encoding = reader.read::<u8>();
83-
if ttype_encoding != DW_EH_PE_omit {
84-
// Rust doesn't analyze exception types, so we don't care about the type table
85-
reader.read_uleb128();
86-
}
87-
88-
let call_site_encoding = reader.read::<u8>();
89-
let call_site_table_length = reader.read_uleb128();
90-
let action_table = reader.ptr.add(call_site_table_length as usize);
89+
reader.read::<u8>()
90+
};
91+
let action_table = unsafe {
92+
let call_site_table_length = reader.read_uleb128();
93+
reader.ptr.add(call_site_table_length as usize)
94+
};
9195
let ip = context.ip;
9296

9397
if !USING_SJLJ_EXCEPTIONS {
9498
// read the callsite table
9599
while reader.ptr < action_table {
96-
// these are offsets rather than pointers;
97-
let cs_start = read_encoded_offset(&mut reader, call_site_encoding)?;
98-
let cs_len = read_encoded_offset(&mut reader, call_site_encoding)?;
99-
let cs_lpad = read_encoded_offset(&mut reader, call_site_encoding)?;
100-
let cs_action_entry = reader.read_uleb128();
101-
// Callsite table is sorted by cs_start, so if we've passed the ip, we
102-
// may stop searching.
103-
if ip < func_start.wrapping_add(cs_start) {
104-
break;
105-
}
106-
if ip < func_start.wrapping_add(cs_start + cs_len) {
107-
if cs_lpad == 0 {
108-
return Ok(EHAction::None);
109-
} else {
110-
let lpad = lpad_base.wrapping_add(cs_lpad);
111-
return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));
100+
unsafe {
101+
// these are offsets rather than pointers;
102+
let cs_start = read_encoded_offset(&mut reader, call_site_encoding)?;
103+
let cs_len = read_encoded_offset(&mut reader, call_site_encoding)?;
104+
let cs_lpad = read_encoded_offset(&mut reader, call_site_encoding)?;
105+
let cs_action_entry = reader.read_uleb128();
106+
// Callsite table is sorted by cs_start, so if we've passed the ip, we
107+
// may stop searching.
108+
if ip < func_start.wrapping_add(cs_start) {
109+
break;
110+
}
111+
if ip < func_start.wrapping_add(cs_start + cs_len) {
112+
if cs_lpad == 0 {
113+
return Ok(EHAction::None);
114+
} else {
115+
let lpad = lpad_base.wrapping_add(cs_lpad);
116+
return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));
117+
}
112118
}
113119
}
114120
}
@@ -125,15 +131,15 @@ pub unsafe fn find_eh_action(lsda: *const u8, context: &EHContext<'_>) -> Result
125131
}
126132
let mut idx = ip.addr();
127133
loop {
128-
let cs_lpad = reader.read_uleb128();
129-
let cs_action_entry = reader.read_uleb128();
134+
let cs_lpad = unsafe{reader.read_uleb128()};
135+
let cs_action_entry = unsafe{reader.read_uleb128()};
130136
idx -= 1;
131137
if idx == 0 {
132138
// Can never have null landing pad for sjlj -- that would have
133139
// been indicated by a -1 call site index.
134140
// FIXME(strict provenance)
135141
let lpad = ptr::with_exposed_provenance((cs_lpad + 1) as usize);
136-
return Ok(interpret_cs_action(action_table, cs_action_entry, lpad));
142+
return Ok(unsafe{interpret_cs_action(action_table, cs_action_entry, lpad)});
137143
}
138144
}
139145
}
@@ -151,9 +157,9 @@ unsafe fn interpret_cs_action(
151157
} else {
152158
// If lpad != 0 and cs_action_entry != 0, we have to check ttype_index.
153159
// If ttype_index == 0 under the condition, we take cleanup action.
154-
let action_record = action_table.offset(cs_action_entry as isize - 1);
160+
let action_record = unsafe{action_table.offset(cs_action_entry as isize - 1)};
155161
let mut action_reader = DwarfReader::new(action_record);
156-
let ttype_index = action_reader.read_sleb128();
162+
let ttype_index = unsafe{action_reader.read_sleb128()};
157163
if ttype_index == 0 {
158164
EHAction::Cleanup(lpad)
159165
} else if ttype_index > 0 {
@@ -186,18 +192,20 @@ unsafe fn read_encoded_offset(reader: &mut DwarfReader, encoding: u8) -> Result<
186192
if encoding == DW_EH_PE_omit || encoding & 0xF0 != 0 {
187193
return Err(());
188194
}
189-
let result = match encoding & 0x0F {
190-
// despite the name, LLVM also uses absptr for offsets instead of pointers
191-
DW_EH_PE_absptr => reader.read::<usize>(),
192-
DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
193-
DW_EH_PE_udata2 => reader.read::<u16>() as usize,
194-
DW_EH_PE_udata4 => reader.read::<u32>() as usize,
195-
DW_EH_PE_udata8 => reader.read::<u64>() as usize,
196-
DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
197-
DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
198-
DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
199-
DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
200-
_ => return Err(()),
195+
let result = unsafe {
196+
match encoding & 0x0F {
197+
// despite the name, LLVM also uses absptr for offsets instead of pointers
198+
DW_EH_PE_absptr => reader.read::<usize>(),
199+
DW_EH_PE_uleb128 => reader.read_uleb128() as usize,
200+
DW_EH_PE_udata2 => reader.read::<u16>() as usize,
201+
DW_EH_PE_udata4 => reader.read::<u32>() as usize,
202+
DW_EH_PE_udata8 => reader.read::<u64>() as usize,
203+
DW_EH_PE_sleb128 => reader.read_sleb128() as usize,
204+
DW_EH_PE_sdata2 => reader.read::<i16>() as usize,
205+
DW_EH_PE_sdata4 => reader.read::<i32>() as usize,
206+
DW_EH_PE_sdata8 => reader.read::<i64>() as usize,
207+
_ => return Err(()),
208+
}
201209
};
202210
Ok(result)
203211
}
@@ -250,14 +258,14 @@ unsafe fn read_encoded_pointer(
250258
if encoding & 0x0F != DW_EH_PE_absptr {
251259
return Err(());
252260
}
253-
reader.read::<*const u8>()
261+
unsafe{reader.read::<*const u8>()}
254262
} else {
255-
let offset = read_encoded_offset(reader, encoding & 0x0F)?;
263+
let offset = unsafe{read_encoded_offset(reader, encoding & 0x0F)?};
256264
base_ptr.wrapping_add(offset)
257265
};
258266

259267
if encoding & DW_EH_PE_indirect != 0 {
260-
ptr = *(ptr.cast::<*const u8>());
268+
ptr = unsafe{*(ptr.cast::<*const u8>())};
261269
}
262270

263271
Ok(ptr)

‎library/std/src/sys/personality/dwarf/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@
55
// This module is used only by x86_64-pc-windows-gnu for now, but we
66
// are compiling it everywhere to avoid regressions.
77
#![allow(unused)]
8+
#![forbid(unsafe_op_in_unsafe_fn)]
89

910
#[cfg(test)]
1011
mod tests;
@@ -17,7 +18,6 @@ pub struct DwarfReader {
1718
pub ptr: *const u8,
1819
}
1920

20-
#[forbid(unsafe_op_in_unsafe_fn)]
2121
impl DwarfReader {
2222
pub fn new(ptr: *const u8) -> DwarfReader {
2323
DwarfReader { ptr }

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /