Skip to content

Commit 431840e

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of rust-lang#108089 - Zoxc:windows-tls, r=wesleywiser
Support TLS access into dylibs on Windows This allows access to `#[thread_local]` in upstream dylibs on Windows by introducing a MIR shim to return the address of the thread local. Accesses that go into an upstream dylib will call the MIR shim to get the address of it. `convert_tls_rvalues` is introduced in `rustc_codegen_ssa` which rewrites MIR TLS accesses to dummy calls which are replaced with calls to the MIR shims when the dummy calls are lowered to backend calls. A new `dll_tls_export` target option enables this behavior with a `false` value which is set for Windows platforms. This fixes rust-lang#84933.
2 parents 08d5cdd + 6c9d750 commit 431840e

File tree

26 files changed

+232
-71
lines changed

26 files changed

+232
-71
lines changed

Diff for: ‎compiler/rustc_codegen_cranelift/src/constant.rs

+16-6
Original file line numberDiff line numberDiff line change
@@ -54,12 +54,22 @@ pub(crate) fn codegen_tls_ref<'tcx>(
5454
def_id: DefId,
5555
layout: TyAndLayout<'tcx>,
5656
) -> CValue<'tcx> {
57-
let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
58-
let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
59-
if fx.clif_comments.enabled() {
60-
fx.add_comment(local_data_id, format!("tls {:?}", def_id));
61-
}
62-
let tls_ptr = fx.bcx.ins().tls_value(fx.pointer_type, local_data_id);
57+
let tls_ptr = if !def_id.is_local() && fx.tcx.needs_thread_local_shim(def_id) {
58+
let instance = ty::Instance {
59+
def: ty::InstanceDef::ThreadLocalShim(def_id),
60+
substs: ty::InternalSubsts::empty(),
61+
};
62+
let func_ref = fx.get_function_ref(instance);
63+
let call = fx.bcx.ins().call(func_ref, &[]);
64+
fx.bcx.func.dfg.first_result(call)
65+
} else {
66+
let data_id = data_id_for_static(fx.tcx, fx.module, def_id, false);
67+
let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
68+
if fx.clif_comments.enabled() {
69+
fx.add_comment(local_data_id, format!("tls {:?}", def_id));
70+
}
71+
fx.bcx.ins().tls_value(fx.pointer_type, local_data_id)
72+
};
6373
CValue::by_val(tls_ptr, layout)
6474
}
6575

Diff for: ‎compiler/rustc_codegen_ssa/src/back/symbol_export.rs

+33-7
Original file line numberDiff line numberDiff line change
@@ -178,14 +178,29 @@ fn exported_symbols_provider_local(
178178

179179
// FIXME: Sorting this is unnecessary since we are sorting later anyway.
180180
// Can we skip the later sorting?
181-
let mut symbols: Vec<_> = tcx.with_stable_hashing_context(|hcx| {
182-
tcx.reachable_non_generics(LOCAL_CRATE)
183-
.to_sorted(&hcx, true)
184-
.into_iter()
185-
.map(|(&def_id, &info)| (ExportedSymbol::NonGeneric(def_id), info))
186-
.collect()
181+
let sorted = tcx.with_stable_hashing_context(|hcx| {
182+
tcx.reachable_non_generics(LOCAL_CRATE).to_sorted(&hcx, true)
187183
});
188184

185+
let mut symbols: Vec<_> =
186+
sorted.iter().map(|(&def_id, &info)| (ExportedSymbol::NonGeneric(def_id), info)).collect();
187+
188+
// Export TLS shims
189+
if !tcx.sess.target.dll_tls_export {
190+
symbols.extend(sorted.iter().filter_map(|(&def_id, &info)| {
191+
tcx.needs_thread_local_shim(def_id).then(|| {
192+
(
193+
ExportedSymbol::ThreadLocalShim(def_id),
194+
SymbolExportInfo {
195+
level: info.level,
196+
kind: SymbolExportKind::Text,
197+
used: info.used,
198+
},
199+
)
200+
})
201+
}))
202+
}
203+
189204
if tcx.entry_fn(()).is_some() {
190205
let exported_symbol =
191206
ExportedSymbol::NoDefId(SymbolName::new(tcx, tcx.sess.target.entry_name.as_ref()));
@@ -380,7 +395,9 @@ fn upstream_monomorphizations_provider(
380395
continue;
381396
}
382397
}
383-
ExportedSymbol::NonGeneric(..) | ExportedSymbol::NoDefId(..) => {
398+
ExportedSymbol::NonGeneric(..)
399+
| ExportedSymbol::ThreadLocalShim(..)
400+
| ExportedSymbol::NoDefId(..) => {
384401
// These are no monomorphizations
385402
continue;
386403
}
@@ -500,6 +517,13 @@ pub fn symbol_name_for_instance_in_crate<'tcx>(
500517
instantiating_crate,
501518
)
502519
}
520+
ExportedSymbol::ThreadLocalShim(def_id) => {
521+
rustc_symbol_mangling::symbol_name_for_instance_in_crate(
522+
tcx,
523+
Instance::new(def_id, ty::InternalSubsts::empty()),
524+
instantiating_crate,
525+
)
526+
}
503527
ExportedSymbol::DropGlue(ty) => rustc_symbol_mangling::symbol_name_for_instance_in_crate(
504528
tcx,
505529
Instance::resolve_drop_in_place(tcx, ty),
@@ -548,6 +572,8 @@ pub fn linking_symbol_name_for_instance_in_crate<'tcx>(
548572
ExportedSymbol::DropGlue(..) => None,
549573
// NoDefId always follow the target's default symbol decoration scheme.
550574
ExportedSymbol::NoDefId(..) => None,
575+
// ThreadLocalShim always follow the target's default symbol decoration scheme.
576+
ExportedSymbol::ThreadLocalShim(..) => None,
551577
};
552578

553579
let (conv, args) = instance

Diff for: ‎compiler/rustc_codegen_ssa/src/mir/rvalue.rs

+13-1
Original file line numberDiff line numberDiff line change
@@ -462,8 +462,20 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
462462

463463
mir::Rvalue::ThreadLocalRef(def_id) => {
464464
assert!(bx.cx().tcx().is_static(def_id));
465-
let static_ = bx.get_static(def_id);
466465
let layout = bx.layout_of(bx.cx().tcx().static_ptr_ty(def_id));
466+
let static_ = if !def_id.is_local() && bx.cx().tcx().needs_thread_local_shim(def_id)
467+
{
468+
let instance = ty::Instance {
469+
def: ty::InstanceDef::ThreadLocalShim(def_id),
470+
substs: ty::InternalSubsts::empty(),
471+
};
472+
let fn_ptr = bx.get_fn_addr(instance);
473+
let fn_abi = bx.fn_abi_of_instance(instance, ty::List::empty());
474+
let fn_ty = bx.fn_decl_backend_type(&fn_abi);
475+
bx.call(fn_ty, Some(fn_abi), fn_ptr, &[], None)
476+
} else {
477+
bx.get_static(def_id)
478+
};
467479
OperandRef { val: OperandValue::Immediate(static_), layout }
468480
}
469481
mir::Rvalue::Use(ref operand) => self.codegen_operand(bx, operand),

Diff for: ‎compiler/rustc_const_eval/src/interpret/terminator.rs

+1
Original file line numberDiff line numberDiff line change
@@ -390,6 +390,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
390390
| ty::InstanceDef::FnPtrShim(..)
391391
| ty::InstanceDef::DropGlue(..)
392392
| ty::InstanceDef::CloneShim(..)
393+
| ty::InstanceDef::ThreadLocalShim(..)
393394
| ty::InstanceDef::Item(_) => {
394395
// We need MIR for this fn
395396
let Some((body, instance)) =

Diff for: ‎compiler/rustc_middle/src/middle/exported_symbols.rs

+5
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,7 @@ pub enum ExportedSymbol<'tcx> {
4343
NonGeneric(DefId),
4444
Generic(DefId, SubstsRef<'tcx>),
4545
DropGlue(Ty<'tcx>),
46+
ThreadLocalShim(DefId),
4647
NoDefId(ty::SymbolName<'tcx>),
4748
}
4849

@@ -58,6 +59,10 @@ impl<'tcx> ExportedSymbol<'tcx> {
5859
ExportedSymbol::DropGlue(ty) => {
5960
tcx.symbol_name(ty::Instance::resolve_drop_in_place(tcx, ty))
6061
}
62+
ExportedSymbol::ThreadLocalShim(def_id) => tcx.symbol_name(ty::Instance {
63+
def: ty::InstanceDef::ThreadLocalShim(def_id),
64+
substs: ty::InternalSubsts::empty(),
65+
}),
6166
ExportedSymbol::NoDefId(symbol_name) => symbol_name,
6267
}
6368
}

Diff for: ‎compiler/rustc_middle/src/mir/mono.rs

+1
Original file line numberDiff line numberDiff line change
@@ -381,6 +381,7 @@ impl<'tcx> CodegenUnit<'tcx> {
381381
| InstanceDef::Virtual(..)
382382
| InstanceDef::ClosureOnceShim { .. }
383383
| InstanceDef::DropGlue(..)
384+
| InstanceDef::ThreadLocalShim(..)
384385
| InstanceDef::CloneShim(..) => None,
385386
}
386387
}

Diff for: ‎compiler/rustc_middle/src/mir/tcx.rs

+1-11
Original file line numberDiff line numberDiff line change
@@ -164,17 +164,7 @@ impl<'tcx> Rvalue<'tcx> {
164164
Rvalue::Repeat(ref operand, count) => {
165165
tcx.mk_array_with_const_len(operand.ty(local_decls, tcx), count)
166166
}
167-
Rvalue::ThreadLocalRef(did) => {
168-
let static_ty = tcx.type_of(did).subst_identity();
169-
if tcx.is_mutable_static(did) {
170-
tcx.mk_mut_ptr(static_ty)
171-
} else if tcx.is_foreign_item(did) {
172-
tcx.mk_imm_ptr(static_ty)
173-
} else {
174-
// FIXME: These things don't *really* have 'static lifetime.
175-
tcx.mk_imm_ref(tcx.lifetimes.re_static, static_ty)
176-
}
177-
}
167+
Rvalue::ThreadLocalRef(did) => tcx.thread_local_ptr_ty(did),
178168
Rvalue::Ref(reg, bk, ref place) => {
179169
let place_ty = place.ty(local_decls, tcx).ty;
180170
tcx.mk_ref(reg, ty::TypeAndMut { ty: place_ty, mutbl: bk.to_mutbl_lossy() })

Diff for: ‎compiler/rustc_middle/src/mir/visit.rs

+1
Original file line numberDiff line numberDiff line change
@@ -335,6 +335,7 @@ macro_rules! make_mir_visitor {
335335
ty::InstanceDef::VTableShim(_def_id) |
336336
ty::InstanceDef::ReifyShim(_def_id) |
337337
ty::InstanceDef::Virtual(_def_id, _) |
338+
ty::InstanceDef::ThreadLocalShim(_def_id) |
338339
ty::InstanceDef::ClosureOnceShim { call_once: _def_id, track_caller: _ } |
339340
ty::InstanceDef::DropGlue(_def_id, None) => {}
340341

Diff for: ‎compiler/rustc_middle/src/ty/instance.rs

+16-1
Original file line numberDiff line numberDiff line change
@@ -82,6 +82,11 @@ pub enum InstanceDef<'tcx> {
8282
/// The `DefId` is the ID of the `call_once` method in `FnOnce`.
8383
ClosureOnceShim { call_once: DefId, track_caller: bool },
8484

85+
/// Compiler-generated accessor for thread locals which returns a reference to the thread local
86+
/// the `DefId` defines. This is used to export thread locals from dylibs on platforms lacking
87+
/// native support.
88+
ThreadLocalShim(DefId),
89+
8590
/// `core::ptr::drop_in_place::<T>`.
8691
///
8792
/// The `DefId` is for `core::ptr::drop_in_place`.
@@ -149,6 +154,7 @@ impl<'tcx> InstanceDef<'tcx> {
149154
| InstanceDef::FnPtrShim(def_id, _)
150155
| InstanceDef::Virtual(def_id, _)
151156
| InstanceDef::Intrinsic(def_id)
157+
| InstanceDef::ThreadLocalShim(def_id)
152158
| InstanceDef::ClosureOnceShim { call_once: def_id, track_caller: _ }
153159
| InstanceDef::DropGlue(def_id, _)
154160
| InstanceDef::CloneShim(def_id, _) => def_id,
@@ -159,7 +165,9 @@ impl<'tcx> InstanceDef<'tcx> {
159165
pub fn def_id_if_not_guaranteed_local_codegen(self) -> Option<DefId> {
160166
match self {
161167
ty::InstanceDef::Item(def) => Some(def.did),
162-
ty::InstanceDef::DropGlue(def_id, Some(_)) => Some(def_id),
168+
ty::InstanceDef::DropGlue(def_id, Some(_)) | InstanceDef::ThreadLocalShim(def_id) => {
169+
Some(def_id)
170+
}
163171
InstanceDef::VTableShim(..)
164172
| InstanceDef::ReifyShim(..)
165173
| InstanceDef::FnPtrShim(..)
@@ -182,6 +190,7 @@ impl<'tcx> InstanceDef<'tcx> {
182190
| InstanceDef::Intrinsic(def_id)
183191
| InstanceDef::ClosureOnceShim { call_once: def_id, track_caller: _ }
184192
| InstanceDef::DropGlue(def_id, _)
193+
| InstanceDef::ThreadLocalShim(def_id)
185194
| InstanceDef::CloneShim(def_id, _) => ty::WithOptConstParam::unknown(def_id),
186195
}
187196
}
@@ -201,6 +210,7 @@ impl<'tcx> InstanceDef<'tcx> {
201210
let def_id = match *self {
202211
ty::InstanceDef::Item(def) => def.did,
203212
ty::InstanceDef::DropGlue(_, Some(_)) => return false,
213+
ty::InstanceDef::ThreadLocalShim(_) => return false,
204214
_ => return true,
205215
};
206216
matches!(
@@ -241,6 +251,9 @@ impl<'tcx> InstanceDef<'tcx> {
241251
)
242252
});
243253
}
254+
if let ty::InstanceDef::ThreadLocalShim(..) = *self {
255+
return false;
256+
}
244257
tcx.codegen_fn_attrs(self.def_id()).requests_inline()
245258
}
246259

@@ -264,6 +277,7 @@ impl<'tcx> InstanceDef<'tcx> {
264277
pub fn has_polymorphic_mir_body(&self) -> bool {
265278
match *self {
266279
InstanceDef::CloneShim(..)
280+
| InstanceDef::ThreadLocalShim(..)
267281
| InstanceDef::FnPtrShim(..)
268282
| InstanceDef::DropGlue(_, Some(_)) => false,
269283
InstanceDef::ClosureOnceShim { .. }
@@ -295,6 +309,7 @@ fn fmt_instance(
295309
InstanceDef::Item(_) => Ok(()),
296310
InstanceDef::VTableShim(_) => write!(f, " - shim(vtable)"),
297311
InstanceDef::ReifyShim(_) => write!(f, " - shim(reify)"),
312+
InstanceDef::ThreadLocalShim(_) => write!(f, " - shim(tls)"),
298313
InstanceDef::Intrinsic(_) => write!(f, " - intrinsic"),
299314
InstanceDef::Virtual(_, num) => write!(f, " - virtual#{}", num),
300315
InstanceDef::FnPtrShim(_, ty) => write!(f, " - shim({})", ty),

Diff for: ‎compiler/rustc_middle/src/ty/mod.rs

+1
Original file line numberDiff line numberDiff line change
@@ -2345,6 +2345,7 @@ impl<'tcx> TyCtxt<'tcx> {
23452345
| ty::InstanceDef::Virtual(..)
23462346
| ty::InstanceDef::ClosureOnceShim { .. }
23472347
| ty::InstanceDef::DropGlue(..)
2348+
| ty::InstanceDef::ThreadLocalShim(..)
23482349
| ty::InstanceDef::CloneShim(..) => self.mir_shims(instance),
23492350
}
23502351
}

Diff for: ‎compiler/rustc_middle/src/ty/util.rs

+22
Original file line numberDiff line numberDiff line change
@@ -599,6 +599,28 @@ impl<'tcx> TyCtxt<'tcx> {
599599
self.static_mutability(def_id) == Some(hir::Mutability::Mut)
600600
}
601601

602+
/// Returns `true` if the item pointed to by `def_id` is a thread local which needs a
603+
/// thread local shim generated.
604+
#[inline]
605+
pub fn needs_thread_local_shim(self, def_id: DefId) -> bool {
606+
!self.sess.target.dll_tls_export
607+
&& self.is_thread_local_static(def_id)
608+
&& !self.is_foreign_item(def_id)
609+
}
610+
611+
/// Returns the type a reference to the thread local takes in MIR.
612+
pub fn thread_local_ptr_ty(self, def_id: DefId) -> Ty<'tcx> {
613+
let static_ty = self.type_of(def_id).subst_identity();
614+
if self.is_mutable_static(def_id) {
615+
self.mk_mut_ptr(static_ty)
616+
} else if self.is_foreign_item(def_id) {
617+
self.mk_imm_ptr(static_ty)
618+
} else {
619+
// FIXME: These things don't *really* have 'static lifetime.
620+
self.mk_imm_ref(self.lifetimes.re_static, static_ty)
621+
}
622+
}
623+
602624
/// Get the type of the pointer to the static that we use in MIR.
603625
pub fn static_ptr_ty(self, def_id: DefId) -> Ty<'tcx> {
604626
// Make sure that any constants in the static's type are evaluated.

Diff for: ‎compiler/rustc_mir_transform/src/inline.rs

+1
Original file line numberDiff line numberDiff line change
@@ -270,6 +270,7 @@ impl<'tcx> Inliner<'tcx> {
270270
| InstanceDef::FnPtrShim(..)
271271
| InstanceDef::ClosureOnceShim { .. }
272272
| InstanceDef::DropGlue(..)
273+
| InstanceDef::ThreadLocalShim(..)
273274
| InstanceDef::CloneShim(..) => return Ok(()),
274275
}
275276

Diff for: ‎compiler/rustc_mir_transform/src/inline/cycle.rs

+1
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,7 @@ pub(crate) fn mir_callgraph_reachable<'tcx>(
8383
| InstanceDef::ReifyShim(_)
8484
| InstanceDef::FnPtrShim(..)
8585
| InstanceDef::ClosureOnceShim { .. }
86+
| InstanceDef::ThreadLocalShim { .. }
8687
| InstanceDef::CloneShim(..) => {}
8788
InstanceDef::DropGlue(..) => {
8889
// FIXME: A not fully substituted drop shim can cause ICEs if one attempts to

Diff for: ‎compiler/rustc_mir_transform/src/shim.rs

+29
Original file line numberDiff line numberDiff line change
@@ -76,6 +76,7 @@ fn make_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> Body<'
7676

7777
build_drop_shim(tcx, def_id, ty)
7878
}
79+
ty::InstanceDef::ThreadLocalShim(..) => build_thread_local_shim(tcx, instance),
7980
ty::InstanceDef::CloneShim(def_id, ty) => build_clone_shim(tcx, def_id, ty),
8081
ty::InstanceDef::Virtual(..) => {
8182
bug!("InstanceDef::Virtual ({:?}) is for direct calls only", instance)
@@ -321,6 +322,34 @@ impl<'a, 'tcx> DropElaborator<'a, 'tcx> for DropShimElaborator<'a, 'tcx> {
321322
}
322323
}
323324

325+
fn build_thread_local_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'tcx>) -> Body<'tcx> {
326+
let def_id = instance.def_id();
327+
328+
let span = tcx.def_span(def_id);
329+
let source_info = SourceInfo::outermost(span);
330+
331+
let mut blocks = IndexVec::with_capacity(1);
332+
blocks.push(BasicBlockData {
333+
statements: vec![Statement {
334+
source_info,
335+
kind: StatementKind::Assign(Box::new((
336+
Place::return_place(),
337+
Rvalue::ThreadLocalRef(def_id),
338+
))),
339+
}],
340+
terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }),
341+
is_cleanup: false,
342+
});
343+
344+
new_body(
345+
MirSource::from_instance(instance),
346+
blocks,
347+
IndexVec::from_raw(vec![LocalDecl::new(tcx.thread_local_ptr_ty(def_id), span)]),
348+
0,
349+
span,
350+
)
351+
}
352+
324353
/// Builds a `Clone::clone` shim for `self_ty`. Here, `def_id` is `Clone::clone`.
325354
fn build_clone_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>) -> Body<'tcx> {
326355
debug!("build_clone_shim(def_id={:?})", def_id);

0 commit comments

Comments
 (0)