Skip to content

Commit ca4c7d9

Browse files
compiler-errorscompiler-errors
committed
Make a fake body to store typeck results for global_asm
1 parent fdd6d61 commit ca4c7d9

File tree

36 files changed

+241
-217
lines changed

36 files changed

+241
-217
lines changed

‎compiler/rustc_ast_lowering/src/asm.rs

Lines changed: 2 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,12 @@
11
use std::collections::hash_map::Entry;
22
use std::fmt::Write;
33

4-
use rustc_ast::ptr::P;
54
use rustc_ast::*;
65
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
76
use rustc_hir as hir;
87
use rustc_hir::def::{DefKind, Res};
98
use rustc_session::parse::feature_err;
10-
use rustc_span::{Span, kw, sym};
9+
use rustc_span::{Span, sym};
1110
use rustc_target::asm;
1211

1312
use super::LoweringContext;
@@ -230,20 +229,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
230229
tokens: None,
231230
};
232231

233-
// Wrap the expression in an AnonConst.
234-
let parent_def_id = self.current_hir_id_owner.def_id;
235-
let node_id = self.next_node_id();
236-
self.create_def(
237-
parent_def_id,
238-
node_id,
239-
kw::Empty,
240-
DefKind::AnonConst,
241-
*op_sp,
242-
);
243-
let anon_const = AnonConst { id: node_id, value: P(expr) };
244-
hir::InlineAsmOperand::SymFn {
245-
anon_const: self.lower_anon_const_to_anon_const(&anon_const),
246-
}
232+
hir::InlineAsmOperand::SymFn { expr: self.lower_expr(&expr) }
247233
}
248234
}
249235
InlineAsmOperand::Label { block } => {

‎compiler/rustc_ast_lowering/src/item.rs

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -252,7 +252,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
252252
.alloc_from_iter(fm.items.iter().map(|x| self.lower_foreign_item_ref(x))),
253253
},
254254
ItemKind::GlobalAsm(asm) => {
255-
hir::ItemKind::GlobalAsm { asm: self.lower_inline_asm(span, asm) }
255+
let asm = self.lower_inline_asm(span, asm);
256+
let fake_body =
257+
self.lower_body(|this| (&[], this.expr(span, hir::ExprKind::InlineAsm(asm))));
258+
hir::ItemKind::GlobalAsm { asm, fake_body }
256259
}
257260
ItemKind::TyAlias(box TyAlias { generics, where_clauses, ty, .. }) => {
258261
// We lower

‎compiler/rustc_borrowck/src/universal_regions.rs

Lines changed: 24 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -125,6 +125,11 @@ pub(crate) enum DefiningTy<'tcx> {
125125
/// The MIR represents an inline const. The signature has no inputs and a
126126
/// single return value found via `InlineConstArgs::ty`.
127127
InlineConst(DefId, GenericArgsRef<'tcx>),
128+
129+
// Fake body for a global asm. Not particularly useful or interesting,
130+
// but we need it so we can properly store the typeck results of the asm
131+
// operands, which aren't associated with a body otherwise.
132+
GlobalAsm(DefId),
128133
}
129134

130135
impl<'tcx> DefiningTy<'tcx> {
@@ -137,9 +142,10 @@ impl<'tcx> DefiningTy<'tcx> {
137142
DefiningTy::Closure(_, args) => args.as_closure().upvar_tys(),
138143
DefiningTy::CoroutineClosure(_, args) => args.as_coroutine_closure().upvar_tys(),
139144
DefiningTy::Coroutine(_, args) => args.as_coroutine().upvar_tys(),
140-
DefiningTy::FnDef(..) | DefiningTy::Const(..) | DefiningTy::InlineConst(..) => {
141-
ty::List::empty()
142-
}
145+
DefiningTy::FnDef(..)
146+
| DefiningTy::Const(..)
147+
| DefiningTy::InlineConst(..)
148+
| DefiningTy::GlobalAsm(_) => ty::List::empty(),
143149
}
144150
}
145151

@@ -151,7 +157,10 @@ impl<'tcx> DefiningTy<'tcx> {
151157
DefiningTy::Closure(..)
152158
| DefiningTy::CoroutineClosure(..)
153159
| DefiningTy::Coroutine(..) => 1,
154-
DefiningTy::FnDef(..) | DefiningTy::Const(..) | DefiningTy::InlineConst(..) => 0,
160+
DefiningTy::FnDef(..)
161+
| DefiningTy::Const(..)
162+
| DefiningTy::InlineConst(..)
163+
| DefiningTy::GlobalAsm(_) => 0,
155164
}
156165
}
157166

@@ -170,7 +179,8 @@ impl<'tcx> DefiningTy<'tcx> {
170179
| DefiningTy::Coroutine(def_id, ..)
171180
| DefiningTy::FnDef(def_id, ..)
172181
| DefiningTy::Const(def_id, ..)
173-
| DefiningTy::InlineConst(def_id, ..) => def_id,
182+
| DefiningTy::InlineConst(def_id, ..)
183+
| DefiningTy::GlobalAsm(def_id) => def_id,
174184
}
175185
}
176186
}
@@ -410,6 +420,7 @@ impl<'tcx> UniversalRegions<'tcx> {
410420
tcx.def_path_str_with_args(def_id, args),
411421
));
412422
}
423+
DefiningTy::GlobalAsm(_) => unreachable!(),
413424
}
414425
}
415426

@@ -629,6 +640,8 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
629640
DefiningTy::InlineConst(self.mir_def.to_def_id(), args)
630641
}
631642
}
643+
644+
BodyOwnerKind::GlobalAsm => DefiningTy::GlobalAsm(self.mir_def.to_def_id()),
632645
}
633646
}
634647

@@ -662,6 +675,8 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
662675
}
663676

664677
DefiningTy::FnDef(_, args) | DefiningTy::Const(_, args) => args,
678+
679+
DefiningTy::GlobalAsm(_) => ty::List::empty(),
665680
};
666681

667682
let global_mapping = iter::once((tcx.lifetimes.re_static, fr_static));
@@ -798,6 +813,10 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
798813
let ty = args.as_inline_const().ty();
799814
ty::Binder::dummy(tcx.mk_type_list(&[ty]))
800815
}
816+
817+
DefiningTy::GlobalAsm(def_id) => {
818+
ty::Binder::dummy(tcx.mk_type_list(&[tcx.type_of(def_id).instantiate_identity()]))
819+
}
801820
};
802821

803822
// FIXME(#129952): We probably want a more principled approach here.

‎compiler/rustc_codegen_cranelift/src/global_asm.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ use crate::prelude::*;
1616

1717
pub(crate) fn codegen_global_asm_item(tcx: TyCtxt<'_>, global_asm: &mut String, item_id: ItemId) {
1818
let item = tcx.hir().item(item_id);
19-
if let rustc_hir::ItemKind::GlobalAsm { asm } = item.kind {
19+
if let rustc_hir::ItemKind::GlobalAsm { asm, .. } = item.kind {
2020
let is_x86 =
2121
matches!(tcx.sess.asm_arch.unwrap(), InlineAsmArch::X86 | InlineAsmArch::X86_64);
2222

@@ -55,15 +55,15 @@ pub(crate) fn codegen_global_asm_item(tcx: TyCtxt<'_>, global_asm: &mut String,
5555
}
5656
}
5757
}
58-
InlineAsmOperand::SymFn { anon_const } => {
58+
InlineAsmOperand::SymFn { expr } => {
5959
if cfg!(not(feature = "inline_asm_sym")) {
6060
tcx.dcx().span_err(
6161
item.span,
6262
"asm! and global_asm! sym operands are not yet supported",
6363
);
6464
}
6565

66-
let ty = tcx.typeck_body(anon_const.body).node_type(anon_const.hir_id);
66+
let ty = tcx.typeck(item_id.owner_id).expr_ty(expr);
6767
let instance = match ty.kind() {
6868
&ty::FnDef(def_id, args) => Instance::new(def_id, args),
6969
_ => span_bug!(op_sp, "asm sym is not a function"),

‎compiler/rustc_codegen_ssa/src/mono_item.rs

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,7 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
3636
}
3737
MonoItem::GlobalAsm(item_id) => {
3838
let item = cx.tcx().hir().item(item_id);
39-
if let hir::ItemKind::GlobalAsm { asm } = item.kind {
39+
if let hir::ItemKind::GlobalAsm { asm, .. } = item.kind {
4040
let operands: Vec<_> = asm
4141
.operands
4242
.iter()
@@ -71,11 +71,8 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> {
7171
}
7272
}
7373
}
74-
hir::InlineAsmOperand::SymFn { ref anon_const } => {
75-
let ty = cx
76-
.tcx()
77-
.typeck_body(anon_const.body)
78-
.node_type(anon_const.hir_id);
74+
hir::InlineAsmOperand::SymFn { expr } => {
75+
let ty = cx.tcx().typeck(item_id.owner_id).expr_ty(expr);
7976
let instance = match ty.kind() {
8077
&ty::FnDef(def_id, args) => Instance::new(def_id, args),
8178
_ => span_bug!(*op_sp, "asm sym is not a function"),

‎compiler/rustc_hir/src/hir.rs

Lines changed: 21 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1913,13 +1913,18 @@ pub enum BodyOwnerKind {
19131913

19141914
/// Initializer of a `static` item.
19151915
Static(Mutability),
1916+
1917+
/// Fake body for a global asm to store its const-like value types.
1918+
GlobalAsm,
19161919
}
19171920

19181921
impl BodyOwnerKind {
19191922
pub fn is_fn_or_closure(self) -> bool {
19201923
match self {
19211924
BodyOwnerKind::Fn | BodyOwnerKind::Closure => true,
1922-
BodyOwnerKind::Const { .. } | BodyOwnerKind::Static(_) => false,
1925+
BodyOwnerKind::Const { .. } | BodyOwnerKind::Static(_) | BodyOwnerKind::GlobalAsm => {
1926+
false
1927+
}
19231928
}
19241929
}
19251930
}
@@ -3420,7 +3425,7 @@ pub enum InlineAsmOperand<'hir> {
34203425
anon_const: &'hir AnonConst,
34213426
},
34223427
SymFn {
3423-
anon_const: &'hir AnonConst,
3428+
expr: &'hir Expr<'hir>,
34243429
},
34253430
SymStatic {
34263431
path: QPath<'hir>,
@@ -3848,7 +3853,7 @@ impl<'hir> Item<'hir> {
38483853
expect_foreign_mod, (ExternAbi, &'hir [ForeignItemRef]),
38493854
ItemKind::ForeignMod { abi, items }, (*abi, items);
38503855

3851-
expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm { asm }, asm;
3856+
expect_global_asm, &'hir InlineAsm<'hir>, ItemKind::GlobalAsm { asm, .. }, asm;
38523857

38533858
expect_ty_alias, (&'hir Ty<'hir>, &'hir Generics<'hir>),
38543859
ItemKind::TyAlias(ty, generics), (ty, generics);
@@ -4015,7 +4020,15 @@ pub enum ItemKind<'hir> {
40154020
/// An external module, e.g. `extern { .. }`.
40164021
ForeignMod { abi: ExternAbi, items: &'hir [ForeignItemRef] },
40174022
/// Module-level inline assembly (from `global_asm!`).
4018-
GlobalAsm { asm: &'hir InlineAsm<'hir> },
4023+
GlobalAsm {
4024+
asm: &'hir InlineAsm<'hir>,
4025+
/// A fake body which stores typeck results for the global asm's sym_fn
4026+
/// operands, which are represented as path expressions. This body contains
4027+
/// a single [`ExprKind::InlineAsm`] which points to the asm in the field
4028+
/// above, and which is typechecked like a inline asm expr just for the
4029+
/// typeck results.
4030+
fake_body: BodyId,
4031+
},
40194032
/// A type alias, e.g., `type Foo = Bar<u8>`.
40204033
TyAlias(&'hir Ty<'hir>, &'hir Generics<'hir>),
40214034
/// An enum definition, e.g., `enum Foo<A, B> {C<A>, D<B>}`.
@@ -4540,6 +4553,10 @@ impl<'hir> Node<'hir> {
45404553
..
45414554
}) => Some((owner_id.def_id, *body)),
45424555

4556+
Node::Item(Item {
4557+
owner_id, kind: ItemKind::GlobalAsm { asm: _, fake_body }, ..
4558+
}) => Some((owner_id.def_id, *fake_body)),
4559+
45434560
Node::Expr(Expr { kind: ExprKind::Closure(Closure { def_id, body, .. }), .. }) => {
45444561
Some((*def_id, *body))
45454562
}

‎compiler/rustc_hir/src/intravisit.rs

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -575,9 +575,13 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
575575
try_visit!(visitor.visit_id(item.hir_id()));
576576
walk_list!(visitor, visit_foreign_item_ref, items);
577577
}
578-
ItemKind::GlobalAsm { asm } => {
578+
ItemKind::GlobalAsm { asm: _, fake_body } => {
579579
try_visit!(visitor.visit_id(item.hir_id()));
580-
try_visit!(visitor.visit_inline_asm(asm, item.hir_id()));
580+
// Visit the fake body, which contains the asm statement.
581+
// Therefore we should not visit the asm statement again
582+
// outside of the body, or some visitors won't have their
583+
// typeck results set correctly.
584+
try_visit!(visitor.visit_nested_body(fake_body));
581585
}
582586
ItemKind::TyAlias(ref ty, ref generics) => {
583587
try_visit!(visitor.visit_id(item.hir_id()));
@@ -1444,10 +1448,12 @@ pub fn walk_inline_asm<'v, V: Visitor<'v>>(
14441448
try_visit!(visitor.visit_expr(in_expr));
14451449
visit_opt!(visitor, visit_expr, out_expr);
14461450
}
1447-
InlineAsmOperand::Const { anon_const, .. }
1448-
| InlineAsmOperand::SymFn { anon_const, .. } => {
1451+
InlineAsmOperand::Const { anon_const, .. } => {
14491452
try_visit!(visitor.visit_anon_const(anon_const));
14501453
}
1454+
InlineAsmOperand::SymFn { expr, .. } => {
1455+
try_visit!(visitor.visit_expr(expr));
1456+
}
14511457
InlineAsmOperand::SymStatic { path, .. } => {
14521458
try_visit!(visitor.visit_qpath(path, id, *op_sp));
14531459
}

‎compiler/rustc_hir_analysis/src/check/check.rs

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,6 @@ use rustc_lint_defs::builtin::{
1515
use rustc_middle::hir::nested_filter;
1616
use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
1717
use rustc_middle::middle::stability::EvalResult;
18-
use rustc_middle::span_bug;
1918
use rustc_middle::ty::error::TypeErrorToStringExt;
2019
use rustc_middle::ty::fold::{BottomUpFolder, fold_regions};
2120
use rustc_middle::ty::layout::{LayoutError, MAX_SIMD_LANES};
@@ -35,7 +34,6 @@ use {rustc_attr_parsing as attr, rustc_hir as hir};
3534

3635
use super::compare_impl_item::check_type_bounds;
3736
use super::*;
38-
use crate::check::intrinsicck::InlineAsmCtxt;
3937

4038
pub fn check_abi(tcx: TyCtxt<'_>, span: Span, abi: ExternAbi) {
4139
if !tcx.sess.target.is_abi_supported(abi) {
@@ -895,13 +893,6 @@ pub(crate) fn check_item_type(tcx: TyCtxt<'_>, def_id: LocalDefId) {
895893
}
896894
}
897895
}
898-
DefKind::GlobalAsm => {
899-
let it = tcx.hir().expect_item(def_id);
900-
let hir::ItemKind::GlobalAsm { asm } = it.kind else {
901-
span_bug!(it.span, "DefKind::GlobalAsm but got {:#?}", it)
902-
};
903-
InlineAsmCtxt::new_global_asm(tcx, def_id).check_asm(asm);
904-
}
905896
_ => {}
906897
}
907898
}

‎compiler/rustc_hir_analysis/src/check/intrinsicck.rs

Lines changed: 26 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::FxIndexSet;
66
use rustc_hir::def_id::DefId;
77
use rustc_hir::{self as hir, LangItem};
88
use rustc_middle::bug;
9-
use rustc_middle::ty::{self, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, UintTy};
9+
use rustc_middle::ty::{self, Article, FloatTy, IntTy, Ty, TyCtxt, TypeVisitableExt, UintTy};
1010
use rustc_session::lint;
1111
use rustc_span::def_id::LocalDefId;
1212
use rustc_span::{Symbol, sym};
@@ -30,31 +30,19 @@ enum NonAsmTypeReason<'tcx> {
3030
}
3131

3232
impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
33-
pub fn new_global_asm(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Self {
33+
pub fn new(
34+
tcx: TyCtxt<'tcx>,
35+
def_id: LocalDefId,
36+
get_operand_ty: impl Fn(&hir::Expr<'tcx>) -> Ty<'tcx> + 'a,
37+
) -> Self {
3438
InlineAsmCtxt {
3539
tcx,
3640
typing_env: ty::TypingEnv {
3741
typing_mode: ty::TypingMode::non_body_analysis(),
3842
param_env: ty::ParamEnv::empty(),
3943
},
4044
target_features: tcx.asm_target_features(def_id),
41-
expr_ty: Box::new(|e| bug!("asm operand in global asm: {e:?}")),
42-
}
43-
}
44-
45-
// FIXME(#132279): This likely causes us to incorrectly handle opaque types in their
46-
// defining scope.
47-
pub fn new_in_fn(
48-
tcx: TyCtxt<'tcx>,
49-
typing_env: ty::TypingEnv<'tcx>,
50-
def_id: LocalDefId,
51-
expr_ty: impl Fn(&hir::Expr<'tcx>) -> Ty<'tcx> + 'a,
52-
) -> Self {
53-
InlineAsmCtxt {
54-
tcx,
55-
typing_env,
56-
target_features: tcx.asm_target_features(def_id),
57-
expr_ty: Box::new(expr_ty),
45+
expr_ty: Box::new(get_operand_ty),
5846
}
5947
}
6048

@@ -492,11 +480,25 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
492480
);
493481
}
494482
// Typeck has checked that SymFn refers to a function.
495-
hir::InlineAsmOperand::SymFn { anon_const } => {
496-
debug_assert_matches!(
497-
self.tcx.type_of(anon_const.def_id).instantiate_identity().kind(),
498-
ty::Error(_) | ty::FnDef(..)
499-
);
483+
hir::InlineAsmOperand::SymFn { expr } => {
484+
let ty = self.expr_ty(expr);
485+
match ty.kind() {
486+
ty::FnDef(..) => {}
487+
ty::Error(_) => {}
488+
_ => {
489+
self.tcx
490+
.dcx()
491+
.struct_span_err(op_sp, "invalid `sym` operand")
492+
.with_span_label(
493+
expr.span,
494+
format!("is {} `{}`", ty.kind().article(), ty),
495+
)
496+
.with_help(
497+
"`sym` operands must refer to either a function or a static",
498+
)
499+
.emit();
500+
}
501+
}
500502
}
501503
// AST lowering guarantees that SymStatic points to a static.
502504
hir::InlineAsmOperand::SymStatic { .. } => {}

‎compiler/rustc_hir_analysis/src/collect/generics_of.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -189,8 +189,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
189189
// Exclude `GlobalAsm` here which cannot have generics.
190190
Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
191191
if asm.operands.iter().any(|(op, _op_sp)| match op {
192-
hir::InlineAsmOperand::Const { anon_const }
193-
| hir::InlineAsmOperand::SymFn { anon_const } => {
192+
hir::InlineAsmOperand::Const { anon_const } => {
194193
anon_const.hir_id == hir_id
195194
}
196195
_ => false,

0 commit comments

Comments
 (0)