| Age | Commit message (Collapse) | Author | Lines |
|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Co-Authored-By: Ralf Jung <post@ralfj.de>
Co-Authored-By: Oli Scherer <github333195615777966@oli-obk.de>
|
|
`std::vec`: Add UB check for `set_len`, `from_raw_parts_in`, and etc.
Closes rust-lang/rust#143813
I noticed that `from_parts_in` do the similar things like `from_raw_parts_in`, so I add the UB check in the last commit. If it is not appropriate, I will remove it.
And I fix a typo in the first commit.
r? `@scottmcm`
|
|
signature
|
|
|
|
update `cfg_select!` documentation
tracking issue: https://github.com/rust-lang/rust/issues/115585
After rust-lang/rust#143461, and with an eye on a soon(ish) stabilization, I think the docs need some work.
The existing text read more like a motivation for the feature existing to me, so I've tried to now be a bit more descriptive. Still, suggestions are very welcome.
I also added a test for an empty `select! {}` because it's just the sort of thing that might break.
r? ``@traviscross``
|
|
Add experimental `backtrace-trace-only` std feature
This experimentally allows building std with backtrace but without symbolisation. It does not affect stable and requires build-std to use. This doesn't change the backtrace crate itself so relies on the optimizer to remove the unused parts.
Example usage:
```toml
# .cargo/config.toml
[unstable]
build-std = ["core", "alloc", "panic_unwind", "std"]
build-std-features = ["backtrace", "backtrace-trace-only", "panic-unwind"]
```
```toml
# Cargo.toml
[profile.release]
opt-level = 3
lto = "thin"
codegen-units = 1
```
Ideally we should split the backtrace feature into `backtrace-trace` and `backtrace-symbolize` (with the latter dependent on the former) because Cargo features tend to work better when they're positive rather than negative. But I'm keen for this experiment not to break existing users.
cc ``@joshtriplett``
|
|
r=Mark-Simulacrum
core: make `str::split_at_unchecked()` inline
This PR adds `#[inline]` to the method `str::split_at_unchecked()`. This is done for two reasons:
1. The method is tiny, e.g. on AMD-64 (<https://godbolt.org/z/ba68fdfxn>):
```asm
movq %rdi, %rax
subq %rcx, %rdx
movq %rsi, (%rdi)
addq %rcx, %rsi
movq %rcx, 8(%rdi)
movq %rsi, 16(%rdi)
movq %rdx, 24(%rdi)
retq
```
2. More importantly, inlining the method enables further automatic optimizations. E.g. if you split at index 3, then in the compiler (rustc, llvm or both) knows that this code cannot fail, and the panicking path is omitted in the generated code:
```rust
pub fn punctuation(i: &str) -> Result<(), ()> {
const THREE_CHARS: &[[u8; 3]] = &[*b"<<=", *b">>=", *b"...", *b"..="];
if let Some((head, _)) = i.split_at_checked(3)
&& THREE_CHARS.contains(&head.as_bytes().try_into().unwrap())
{
Ok(())
} else {
Err(())
}
}
```
<details>
<summary>Without PR</summary>
<https://play.rust-lang.org/?version=stable&mode=release&edition=2024&gist=0234de8158f467eebd73286f20d6e27a>
```asm
playground::punctuation:
subq $40, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movb $1, %al
cmpq $3, %rdx
ja .LBB2_2
je .LBB2_3
.LBB2_11:
addq $40, %rsp
retq
.LBB2_2:
cmpb $-64, 3(%rsi)
jl .LBB2_11
.LBB2_3:
leaq 8(%rsp), %rdi
movl $3, %ecx
callq *core::str::<impl str>::split_at_unchecked@GOTPCREL(%rip)
movq 8(%rsp), %rcx
movb $1, %al
testq %rcx, %rcx
je .LBB2_11
cmpq $3, 16(%rsp)
jne .LBB2_12
movzwl (%rcx), %edx
movzbl 2(%rcx), %ecx
shll $16, %ecx
orl %edx, %ecx
cmpl $4013115, %ecx
jg .LBB2_8
cmpl $3026478, %ecx
je .LBB2_10
cmpl $4009518, %ecx
je .LBB2_10
jmp .LBB2_11
.LBB2_8:
cmpl $4013630, %ecx
je .LBB2_10
cmpl $4013116, %ecx
jne .LBB2_11
.LBB2_10:
xorl %eax, %eax
addq $40, %rsp
retq
.LBB2_12:
leaq .Lanon.d98a7fbb86d10a97c24516e267466134.2(%rip), %rdi
leaq .Lanon.d98a7fbb86d10a97c24516e267466134.1(%rip), %rcx
leaq .Lanon.d98a7fbb86d10a97c24516e267466134.6(%rip), %r8
leaq 7(%rsp), %rdx
movl $43, %esi
callq *core::result::unwrap_failed@GOTPCREL(%rip)
```
</details>
<details>
<summary>With PR</summary>
<https://play.rust-lang.org/?version=stable&mode=release&edition=2024&gist=5d4058c79ce0f6cb1a434190427d2055>
```asm
playground::punctuation:
movb $1, %al
cmpq $3, %rsi
ja .LBB0_2
je .LBB0_3
.LBB0_9:
retq
.LBB0_2:
cmpb $-64, 3(%rdi)
jl .LBB0_9
.LBB0_3:
movzwl (%rdi), %eax
movzbl 2(%rdi), %ecx
shll $16, %ecx
orl %eax, %ecx
movb $1, %al
cmpl $4013115, %ecx
jg .LBB0_6
cmpl $3026478, %ecx
je .LBB0_8
cmpl $4009518, %ecx
je .LBB0_8
jmp .LBB0_9
.LBB0_6:
cmpl $4013630, %ecx
je .LBB0_8
cmpl $4013116, %ecx
jne .LBB0_9
.LBB0_8:
xorl %eax, %eax
retq
```
</details>
|
|
|
|
|
|
|
|
`aarch64`: use `intrinsics::simd` for horizontal add and `abs`
|
|
core: Add `BorrowedCursor::with_unfilled_buf`
Implementation of https://github.com/rust-lang/libs-team/issues/367.
This mainly adds `BorrowedCursor::with_unfilled_buf`, with enables using the unfilled part of a cursor as a `BorrowedBuf`.
Note that unlike the ACP, `BorrowedCursor::unfilled_buf` was moved to a `From` conversion. This is more consistent with other ways of creating a `BorrowedBuf` and hides a bit this conversion that requires unsafe code to be used correctly.
Cc rust-lang/rust#78485 rust-lang/rust#117693
|
|
|
|
`s390x`: document the different rounding flavors
|
|
loongarch: Add basic support for LoongArch32
|
|
`aarch64`: use more of `intrinsics::simd` for min/max
|
|
Add rustc-pull CI automation workflow
|
|
`intrinsic-test`: use runner also for rust
|
|
and make internal terminology consistent
Co-authored-by: Travis Cross <tc@traviscross.com>
|
|
Updates to random number generation APIs
Updates based on discussions about random number generation.
- Add comment on `RandomSource::fill_bytes` about multiple calls, to allow
efficient implementations for random sources that generate a word at a time.
- Drop the `Random` trait in favor of `Distribution<T>`, which will let people
make calls like random(1..=6), and which allows for future expansion to
non-uniform distributions, as well as floating-point. (For now, this is only
implemented for `RangeFull`, to get the interface in place. Subsequent PRs
will implement it for other range types.)
|
|
Don't call WSACleanup on process exit
This isn't necessary as cleanup will happen when the process exits regardless.
fixes rust-lang/rust#141799
|
|
|
|
|
|
|
|
r=oli-obk
Change "allocated object" to "allocation".
These seem like they were missed in <https://github.com/rust-lang/rust/pull/141224>
|
|
Use zero for initialized Once state
By re-labeling which integer represents which internal state for `Once` we can ensure that the initialized state is the all-zero state. This is beneficial because some CPU architectures (such as Arm) have specialized instructions to specifically branch on non-zero, and checking for the initialized state is by far the most important operation.
As an example, take this:
```rust
use std::sync::atomic::{AtomicU32, Ordering};
const INIT: u32 = 3;
#[inline(never)]
#[cold]
pub fn slow(state: &AtomicU32) {
state.store(INIT, Ordering::Release);
}
pub fn ensure_init(state: &AtomicU32) {
if state.load(Ordering::Acquire) != INIT {
slow(state)
}
}
```
If `INIT` is 3 (as is currently the state for `Once`), we see the following assembly on `aarch64-apple-darwin`:
```asm
example::ensure_init::h332061368366e313:
ldapr w8, [x0]
cmp w8, #3
b.ne LBB1_2
ret
LBB1_2:
b example::slow::ha042bd6a4f33724e
```
By changing the `INIT` state to zero we get the following:
```asm
example::ensure_init::h332061368366e313:
ldapr w8, [x0]
cbnz w8, LBB1_2
ret
LBB1_2:
b example::slow::ha042bd6a4f33724e
```
So this PR saves 1 instruction every time a `LazyLock` gets accessed on platforms such as these.
|
|
update issue number for `const_trait_impl`
r? project-const-traits
cc rust-lang/rust#67792 rust-lang/rust#143874
|
|
These seem like they were missed in <https://github.com/rust-lang/rust/pull/141224>
|
|
|
|
This PR adds `#[inline]` to the method `str::split_at_unchecked()`.
This is done for two reasons:
1. The method is tiny, e.g. on AMD-64 (<https://godbolt.org/z/ba68fdfxn>):
```asm
movq %rdi, %rax
subq %rcx, %rdx
movq %rsi, (%rdi)
addq %rcx, %rsi
movq %rcx, 8(%rdi)
movq %rsi, 16(%rdi)
movq %rdx, 24(%rdi)
retq
```
2. More importantly, inlining the method enables further automatic
optimizations. E.g. if you split at index 3, then in the compiler
(rustc, llvm or both) knows that this code cannot fail, and the
panicking path is omitted in the generated code:
```rust
pub fn punctuation(i: &str) -> Result<(), ()> {
const THREE_CHARS: &[[u8; 3]] = &[*b"<<=", *b">>=", *b"...", *b"..="];
if let Some((head, _)) = i.split_at_checked(3)
&& THREE_CHARS.contains(&head.as_bytes().try_into().unwrap())
{
Ok(())
} else {
Err(())
}
}
```
<details>
<summary>Without PR</summary>
<https://play.rust-lang.org/?version=stable&mode=release&edition=2024&gist=0234de8158f467eebd73286f20d6e27a>
```asm
playground::punctuation:
subq $40, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movb $1, %al
cmpq $3, %rdx
ja .LBB2_2
je .LBB2_3
.LBB2_11:
addq $40, %rsp
retq
.LBB2_2:
cmpb $-64, 3(%rsi)
jl .LBB2_11
.LBB2_3:
leaq 8(%rsp), %rdi
movl $3, %ecx
callq *core::str::<impl str>::split_at_unchecked@GOTPCREL(%rip)
movq 8(%rsp), %rcx
movb $1, %al
testq %rcx, %rcx
je .LBB2_11
cmpq $3, 16(%rsp)
jne .LBB2_12
movzwl (%rcx), %edx
movzbl 2(%rcx), %ecx
shll $16, %ecx
orl %edx, %ecx
cmpl $4013115, %ecx
jg .LBB2_8
cmpl $3026478, %ecx
je .LBB2_10
cmpl $4009518, %ecx
je .LBB2_10
jmp .LBB2_11
.LBB2_8:
cmpl $4013630, %ecx
je .LBB2_10
cmpl $4013116, %ecx
jne .LBB2_11
.LBB2_10:
xorl %eax, %eax
addq $40, %rsp
retq
.LBB2_12:
leaq .Lanon.d98a7fbb86d10a97c24516e267466134.2(%rip), %rdi
leaq .Lanon.d98a7fbb86d10a97c24516e267466134.1(%rip), %rcx
leaq .Lanon.d98a7fbb86d10a97c24516e267466134.6(%rip), %r8
leaq 7(%rsp), %rdx
movl $43, %esi
callq *core::result::unwrap_failed@GOTPCREL(%rip)
```
</details>
<details>
<summary>With PR</summary>
<https://play.rust-lang.org/?version=stable&mode=release&edition=2024&gist=5d4058c79ce0f6cb1a434190427d2055>
```asm
playground::punctuation:
movb $1, %al
cmpq $3, %rsi
ja .LBB0_2
je .LBB0_3
.LBB0_9:
retq
.LBB0_2:
cmpb $-64, 3(%rdi)
jl .LBB0_9
.LBB0_3:
movzwl (%rdi), %eax
movzbl 2(%rdi), %ecx
shll $16, %ecx
orl %eax, %ecx
movb $1, %al
cmpl $4013115, %ecx
jg .LBB0_6
cmpl $3026478, %ecx
je .LBB0_8
cmpl $4009518, %ecx
je .LBB0_8
jmp .LBB0_9
.LBB0_6:
cmpl $4013630, %ecx
je .LBB0_8
cmpl $4013116, %ecx
jne .LBB0_9
.LBB0_8:
xorl %eax, %eax
retq
```
</details>
|
|
make `cfg_select` a builtin macro
tracking issue: https://github.com/rust-lang/rust/issues/115585
This parses mostly the same as the `macro cfg_select` version, except:
1. wrapping in double brackets is no longer supported (or needed): `cfg_select {{ /* ... */ }}` is now rejected.
2. in an expression context, the rhs is no longer wrapped in a block, so that this now works:
```rust
fn main() {
println!(cfg_select! {
unix => { "foo" }
_ => { "bar" }
});
}
```
3. a single wildcard rule is now supported: `cfg_select { _ => 1 }` now works
I've also added an error if none of the rules evaluate to true, and warnings for any arms that follow the `_` wildcard rule.
cc `@traviscross` if I'm missing any feature that should/should not be included
r? `@petrochenkov` for the macro logic details
|
|
|
|
constify `From` and `Into`
tracking issue rust-lang/rust#143773
r? ``````@fee1-dead``````
I did not mark any impls elsewhere as `const`, those can happen on their own timeframe and don't need to be part of this MVP. But if there are some core ones you think should be in there I'll happily add them, just couldn't think of any
|
|
slice: Mark `rotate_left`, `rotate_right` unstably const
Tracking issue rust-lang/rust#143812
- Add the const unstable `const_slice_rotate` feature
- Mark `<[T]>::rotate_left` and `<[T]>::rotate_right` as const unstable
The internal rotate functions use [`<*mut T>::replace`](https://doc.rust-lang.org/stable/core/primitive.pointer.html#method.replace) and [`ptr::swap_nonoverlapping`](https://doc.rust-lang.org/stable/core/ptr/fn.swap_nonoverlapping.html) which were const-stabilized in 1.88.
Two changes were needed in the `rotate.rs` module to make these functions const:
1. A usage of `cmp::min` was replaced with a local function implementation of [`Ord::min`](https://doc.rust-lang.org/1.88.0/src/core/cmp.rs.html#1048-1053).
2. A `for start in 1..gcd` loop was changed to a while loop with an increment variable.
This needs libs-api approval and cc-ing const-eval.
|
|
|
|
|
|
|
|
|
|
Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
|
|
Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
|
|
Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
|
|
Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>
|
