Skip to content

Commit 9713ff4

Browse files
borsbors
committed
Auto merge of rust-lang#3494 - rust-lang:rustup-2024-04-20, r=RalfJung
Automatic Rustup
2 parents e9ebc6f + 7952316 commit 9713ff4

File tree

196 files changed

+2456
-979
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

196 files changed

+2456
-979
lines changed

‎Cargo.lock‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5598,6 +5598,7 @@ dependencies = [
55985598
"lazy_static",
55995599
"miropt-test-tools",
56005600
"regex",
5601+
"rustc-hash",
56015602
"semver",
56025603
"termcolor",
56035604
"walkdir",

‎compiler/rustc_ast_lowering/src/format.rs‎

Lines changed: 117 additions & 77 deletions
Original file line numberDiff line numberDiff line change
@@ -20,10 +20,126 @@ impl<'hir> LoweringContext<'_, 'hir> {
2020
let mut fmt = Cow::Borrowed(fmt);
2121
if self.tcx.sess.opts.unstable_opts.flatten_format_args {
2222
fmt = flatten_format_args(fmt);
23-
fmt = inline_literals(fmt);
23+
fmt = self.inline_literals(fmt);
2424
}
2525
expand_format_args(self, sp, &fmt, allow_const)
2626
}
27+
28+
/// Try to convert a literal into an interned string
29+
fn try_inline_lit(&self, lit: token::Lit) -> Option<Symbol> {
30+
match LitKind::from_token_lit(lit) {
31+
Ok(LitKind::Str(s, _)) => Some(s),
32+
Ok(LitKind::Int(n, ty)) => {
33+
match ty {
34+
// unsuffixed integer literals are assumed to be i32's
35+
LitIntType::Unsuffixed => {
36+
(n <= i32::MAX as u128).then_some(Symbol::intern(&n.to_string()))
37+
}
38+
LitIntType::Signed(int_ty) => {
39+
let max_literal = self.int_ty_max(int_ty);
40+
(n <= max_literal).then_some(Symbol::intern(&n.to_string()))
41+
}
42+
LitIntType::Unsigned(uint_ty) => {
43+
let max_literal = self.uint_ty_max(uint_ty);
44+
(n <= max_literal).then_some(Symbol::intern(&n.to_string()))
45+
}
46+
}
47+
}
48+
_ => None,
49+
}
50+
}
51+
52+
/// Get the maximum value of int_ty. It is platform-dependent due to the byte size of isize
53+
fn int_ty_max(&self, int_ty: IntTy) -> u128 {
54+
match int_ty {
55+
IntTy::Isize => self.tcx.data_layout.pointer_size.signed_int_max() as u128,
56+
IntTy::I8 => i8::MAX as u128,
57+
IntTy::I16 => i16::MAX as u128,
58+
IntTy::I32 => i32::MAX as u128,
59+
IntTy::I64 => i64::MAX as u128,
60+
IntTy::I128 => i128::MAX as u128,
61+
}
62+
}
63+
64+
/// Get the maximum value of uint_ty. It is platform-dependent due to the byte size of usize
65+
fn uint_ty_max(&self, uint_ty: UintTy) -> u128 {
66+
match uint_ty {
67+
UintTy::Usize => self.tcx.data_layout.pointer_size.unsigned_int_max(),
68+
UintTy::U8 => u8::MAX as u128,
69+
UintTy::U16 => u16::MAX as u128,
70+
UintTy::U32 => u32::MAX as u128,
71+
UintTy::U64 => u64::MAX as u128,
72+
UintTy::U128 => u128::MAX as u128,
73+
}
74+
}
75+
76+
/// Inline literals into the format string.
77+
///
78+
/// Turns
79+
///
80+
/// `format_args!("Hello, {}! {} {}", "World", 123, x)`
81+
///
82+
/// into
83+
///
84+
/// `format_args!("Hello, World! 123 {}", x)`.
85+
fn inline_literals<'fmt>(&self, mut fmt: Cow<'fmt, FormatArgs>) -> Cow<'fmt, FormatArgs> {
86+
let mut was_inlined = vec![false; fmt.arguments.all_args().len()];
87+
let mut inlined_anything = false;
88+
89+
for i in 0..fmt.template.len() {
90+
let FormatArgsPiece::Placeholder(placeholder) = &fmt.template[i] else { continue };
91+
let Ok(arg_index) = placeholder.argument.index else { continue };
92+
93+
let mut literal = None;
94+
95+
if let FormatTrait::Display = placeholder.format_trait
96+
&& placeholder.format_options == Default::default()
97+
&& let arg = fmt.arguments.all_args()[arg_index].expr.peel_parens_and_refs()
98+
&& let ExprKind::Lit(lit) = arg.kind
99+
{
100+
literal = self.try_inline_lit(lit);
101+
}
102+
103+
if let Some(literal) = literal {
104+
// Now we need to mutate the outer FormatArgs.
105+
// If this is the first time, this clones the outer FormatArgs.
106+
let fmt = fmt.to_mut();
107+
// Replace the placeholder with the literal.
108+
fmt.template[i] = FormatArgsPiece::Literal(literal);
109+
was_inlined[arg_index] = true;
110+
inlined_anything = true;
111+
}
112+
}
113+
114+
// Remove the arguments that were inlined.
115+
if inlined_anything {
116+
let fmt = fmt.to_mut();
117+
118+
let mut remove = was_inlined;
119+
120+
// Don't remove anything that's still used.
121+
for_all_argument_indexes(&mut fmt.template, |index| remove[*index] = false);
122+
123+
// Drop all the arguments that are marked for removal.
124+
let mut remove_it = remove.iter();
125+
fmt.arguments.all_args_mut().retain(|_| remove_it.next() != Some(&true));
126+
127+
// Calculate the mapping of old to new indexes for the remaining arguments.
128+
let index_map: Vec<usize> = remove
129+
.into_iter()
130+
.scan(0, |i, remove| {
131+
let mapped = *i;
132+
*i += !remove as usize;
133+
Some(mapped)
134+
})
135+
.collect();
136+
137+
// Correct the indexes that refer to arguments that have shifted position.
138+
for_all_argument_indexes(&mut fmt.template, |index| *index = index_map[*index]);
139+
}
140+
141+
fmt
142+
}
27143
}
28144

29145
/// Flattens nested `format_args!()` into one.
@@ -103,82 +219,6 @@ fn flatten_format_args(mut fmt: Cow<'_, FormatArgs>) -> Cow<'_, FormatArgs> {
103219
fmt
104220
}
105221

106-
/// Inline literals into the format string.
107-
///
108-
/// Turns
109-
///
110-
/// `format_args!("Hello, {}! {} {}", "World", 123, x)`
111-
///
112-
/// into
113-
///
114-
/// `format_args!("Hello, World! 123 {}", x)`.
115-
fn inline_literals(mut fmt: Cow<'_, FormatArgs>) -> Cow<'_, FormatArgs> {
116-
let mut was_inlined = vec![false; fmt.arguments.all_args().len()];
117-
let mut inlined_anything = false;
118-
119-
for i in 0..fmt.template.len() {
120-
let FormatArgsPiece::Placeholder(placeholder) = &fmt.template[i] else { continue };
121-
let Ok(arg_index) = placeholder.argument.index else { continue };
122-
123-
let mut literal = None;
124-
125-
if let FormatTrait::Display = placeholder.format_trait
126-
&& placeholder.format_options == Default::default()
127-
&& let arg = fmt.arguments.all_args()[arg_index].expr.peel_parens_and_refs()
128-
&& let ExprKind::Lit(lit) = arg.kind
129-
{
130-
if let token::LitKind::Str | token::LitKind::StrRaw(_) = lit.kind
131-
&& let Ok(LitKind::Str(s, _)) = LitKind::from_token_lit(lit)
132-
{
133-
literal = Some(s);
134-
} else if let token::LitKind::Integer = lit.kind
135-
&& let Ok(LitKind::Int(n, _)) = LitKind::from_token_lit(lit)
136-
{
137-
literal = Some(Symbol::intern(&n.to_string()));
138-
}
139-
}
140-
141-
if let Some(literal) = literal {
142-
// Now we need to mutate the outer FormatArgs.
143-
// If this is the first time, this clones the outer FormatArgs.
144-
let fmt = fmt.to_mut();
145-
// Replace the placeholder with the literal.
146-
fmt.template[i] = FormatArgsPiece::Literal(literal);
147-
was_inlined[arg_index] = true;
148-
inlined_anything = true;
149-
}
150-
}
151-
152-
// Remove the arguments that were inlined.
153-
if inlined_anything {
154-
let fmt = fmt.to_mut();
155-
156-
let mut remove = was_inlined;
157-
158-
// Don't remove anything that's still used.
159-
for_all_argument_indexes(&mut fmt.template, |index| remove[*index] = false);
160-
161-
// Drop all the arguments that are marked for removal.
162-
let mut remove_it = remove.iter();
163-
fmt.arguments.all_args_mut().retain(|_| remove_it.next() != Some(&true));
164-
165-
// Calculate the mapping of old to new indexes for the remaining arguments.
166-
let index_map: Vec<usize> = remove
167-
.into_iter()
168-
.scan(0, |i, remove| {
169-
let mapped = *i;
170-
*i += !remove as usize;
171-
Some(mapped)
172-
})
173-
.collect();
174-
175-
// Correct the indexes that refer to arguments that have shifted position.
176-
for_all_argument_indexes(&mut fmt.template, |index| *index = index_map[*index]);
177-
}
178-
179-
fmt
180-
}
181-
182222
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
183223
enum ArgumentType {
184224
Format(FormatTrait),

‎compiler/rustc_codegen_cranelift/patches/0030-stdlib-Revert-use-raw-dylib-for-Windows-futex-APIs.patch‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
From 0d741cf82c3c908616abd39dc84ebf7d8702e0c3 Mon Sep 17 00:00:00 2001
2+
From: Chris Denton <chris@chrisdenton.dev>
3+
Date: Tue, 16 Apr 2024 15:51:34 +0000
4+
Subject: [PATCH] Revert use raw-dylib for Windows futex APIs
5+
6+
---
7+
library/std/src/sys/pal/windows/c.rs | 14 +-------------
8+
1 file changed, 1 insertion(+), 13 deletions(-)
9+
10+
diff --git a/library/std/src/sys/pal/windows/c.rs b/library/std/src/sys/pal/windows/c.rs
11+
index 9d58ce05f01..1c828bac4b6 100644
12+
--- a/library/std/src/sys/pal/windows/c.rs
13+
+++ b/library/std/src/sys/pal/windows/c.rs
14+
@@ -357,19 +357,7 @@ pub fn GetTempPath2W(bufferlength: u32, buffer: PWSTR) -> u32 {
15+
}
16+
17+
#[cfg(not(target_vendor = "win7"))]
18+
-// Use raw-dylib to import synchronization functions to workaround issues with the older mingw import library.
19+
-#[cfg_attr(
20+
- target_arch = "x86",
21+
- link(
22+
- name = "api-ms-win-core-synch-l1-2-0",
23+
- kind = "raw-dylib",
24+
- import_name_type = "undecorated"
25+
- )
26+
-)]
27+
-#[cfg_attr(
28+
- not(target_arch = "x86"),
29+
- link(name = "api-ms-win-core-synch-l1-2-0", kind = "raw-dylib")
30+
-)]
31+
+#[link(name = "synchronization")]
32+
extern "system" {
33+
pub fn WaitOnAddress(
34+
address: *const c_void,
35+
--
36+
2.42.0.windows.2
37+

‎compiler/rustc_codegen_cranelift/src/constant.rs‎

Lines changed: 19 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ pub(crate) fn codegen_const_value<'tcx>(
110110
if fx.clif_type(layout.ty).is_some() {
111111
return CValue::const_val(fx, layout, int);
112112
} else {
113-
let raw_val = int.size().truncate(int.to_bits(int.size()).unwrap());
113+
let raw_val = int.size().truncate(int.assert_bits(int.size()));
114114
let val = match int.size().bytes() {
115115
1 => fx.bcx.ins().iconst(types::I8, raw_val as i64),
116116
2 => fx.bcx.ins().iconst(types::I16, raw_val as i64),
@@ -491,27 +491,24 @@ pub(crate) fn mir_operand_get_const_val<'tcx>(
491491
return None;
492492
}
493493
let scalar_int = mir_operand_get_const_val(fx, operand)?;
494-
let scalar_int = match fx
495-
.layout_of(*ty)
496-
.size
497-
.cmp(&scalar_int.size())
498-
{
499-
Ordering::Equal => scalar_int,
500-
Ordering::Less => match ty.kind() {
501-
ty::Uint(_) => ScalarInt::try_from_uint(
502-
scalar_int.try_to_uint(scalar_int.size()).unwrap(),
503-
fx.layout_of(*ty).size,
504-
)
505-
.unwrap(),
506-
ty::Int(_) => ScalarInt::try_from_int(
507-
scalar_int.try_to_int(scalar_int.size()).unwrap(),
508-
fx.layout_of(*ty).size,
509-
)
510-
.unwrap(),
511-
_ => unreachable!(),
512-
},
513-
Ordering::Greater => return None,
514-
};
494+
let scalar_int =
495+
match fx.layout_of(*ty).size.cmp(&scalar_int.size()) {
496+
Ordering::Equal => scalar_int,
497+
Ordering::Less => match ty.kind() {
498+
ty::Uint(_) => ScalarInt::try_from_uint(
499+
scalar_int.assert_uint(scalar_int.size()),
500+
fx.layout_of(*ty).size,
501+
)
502+
.unwrap(),
503+
ty::Int(_) => ScalarInt::try_from_int(
504+
scalar_int.assert_int(scalar_int.size()),
505+
fx.layout_of(*ty).size,
506+
)
507+
.unwrap(),
508+
_ => unreachable!(),
509+
},
510+
Ordering::Greater => return None,
511+
};
515512
computed_scalar_int = Some(scalar_int);
516513
}
517514
Rvalue::Use(operand) => {

‎compiler/rustc_codegen_cranelift/src/value_and_place.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -326,7 +326,7 @@ impl<'tcx> CValue<'tcx> {
326326

327327
let val = match layout.ty.kind() {
328328
ty::Uint(UintTy::U128) | ty::Int(IntTy::I128) => {
329-
let const_val = const_val.to_bits(layout.size).unwrap();
329+
let const_val = const_val.assert_bits(layout.size);
330330
let lsb = fx.bcx.ins().iconst(types::I64, const_val as u64 as i64);
331331
let msb = fx.bcx.ins().iconst(types::I64, (const_val >> 64) as u64 as i64);
332332
fx.bcx.ins().iconcat(lsb, msb)
@@ -338,7 +338,7 @@ impl<'tcx> CValue<'tcx> {
338338
| ty::Ref(..)
339339
| ty::RawPtr(..)
340340
| ty::FnPtr(..) => {
341-
let raw_val = const_val.size().truncate(const_val.to_bits(layout.size).unwrap());
341+
let raw_val = const_val.size().truncate(const_val.assert_bits(layout.size));
342342
fx.bcx.ins().iconst(clif_ty, raw_val as i64)
343343
}
344344
ty::Float(FloatTy::F32) => {

‎compiler/rustc_codegen_gcc/src/builder.rs‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ use rustc_span::Span;
3131
use rustc_target::abi::{
3232
self, call::FnAbi, Align, HasDataLayout, Size, TargetDataLayout, WrappingRange,
3333
};
34-
use rustc_target::spec::{HasTargetSpec, Target};
34+
use rustc_target::spec::{HasTargetSpec, HasWasmCAbiOpt, Target, WasmCAbi};
3535

3636
use crate::common::{type_is_pointer, SignType, TypeReflection};
3737
use crate::context::CodegenCx;
@@ -2352,6 +2352,12 @@ impl<'tcx> HasTargetSpec for Builder<'_, '_, 'tcx> {
23522352
}
23532353
}
23542354

2355+
impl<'tcx> HasWasmCAbiOpt for Builder<'_, '_, 'tcx> {
2356+
fn wasm_c_abi_opt(&self) -> WasmCAbi {
2357+
self.cx.wasm_c_abi_opt()
2358+
}
2359+
}
2360+
23552361
pub trait ToGccComp {
23562362
fn to_gcc_comparison(&self) -> ComparisonOp;
23572363
}

‎compiler/rustc_codegen_gcc/src/context.rs‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ use rustc_span::{source_map::respan, Span};
2020
use rustc_target::abi::{
2121
call::FnAbi, HasDataLayout, PointeeInfo, Size, TargetDataLayout, VariantIdx,
2222
};
23-
use rustc_target::spec::{HasTargetSpec, Target, TlsModel};
23+
use rustc_target::spec::{HasTargetSpec, HasWasmCAbiOpt, Target, TlsModel, WasmCAbi};
2424

2525
use crate::callee::get_fn;
2626
use crate::common::SignType;
@@ -557,6 +557,12 @@ impl<'gcc, 'tcx> HasTargetSpec for CodegenCx<'gcc, 'tcx> {
557557
}
558558
}
559559

560+
impl<'gcc, 'tcx> HasWasmCAbiOpt for CodegenCx<'gcc, 'tcx> {
561+
fn wasm_c_abi_opt(&self) -> WasmCAbi {
562+
self.tcx.sess.opts.unstable_opts.wasm_c_abi
563+
}
564+
}
565+
560566
impl<'gcc, 'tcx> LayoutOfHelpers<'tcx> for CodegenCx<'gcc, 'tcx> {
561567
type LayoutOfResult = TyAndLayout<'tcx>;
562568

‎compiler/rustc_const_eval/src/interpret/discriminant.rs‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -295,8 +295,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
295295
&niche_start_val,
296296
)?
297297
.to_scalar()
298-
.try_to_int()
299-
.unwrap();
298+
.assert_int();
300299
Ok(Some((tag, tag_field)))
301300
}
302301
}

0 commit comments

Comments
 (0)