Lower TLS to calls for rvalues directly

Author: Zoxc

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -12,8 +12,7 @@ use crate::MemFlags;
 use rustc_ast as ast;
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_hir::lang_items::LangItem;
-use rustc_hir::Unsafety;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::Idx;
 use rustc_middle::mir::{self, AssertKind, SwitchTargets};
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
 use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
@@ -744,58 +743,25 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let source_info = terminator.source_info;
         let span = source_info.span;
 
-        let thread_local_shim_call = if !self.call_thread_local_shims.is_empty() {
-            self.call_thread_local_shims.iter().find(|e| &e.0 == func).map(|e| e.1)
-        } else {
-            None
-        };
+        // Create the callee. This is a fn ptr or zero-sized and hence a kind of scalar.
+        let callee = self.codegen_operand(bx, func);
 
-        let (sig, instance, mut llfn) = match thread_local_shim_call {
-            Some(thread_local) => {
-                // Replace thread local dummy calls with calls to the real shim
-                let instance = ty::Instance {
-                    def: ty::InstanceDef::ThreadLocalShim(thread_local),
-                    substs: ty::InternalSubsts::empty(),
-                };
-                let ty = mir::Rvalue::ThreadLocalRef(thread_local).ty(&IndexVec::new(), bx.tcx());
-                (
-                    ty::Binder::dummy(bx.tcx().mk_fn_sig(
-                        [].iter(),
-                        &ty,
-                        false,
-                        Unsafety::Normal,
-                        Abi::Unadjusted,
-                    )),
-                    Some(instance),
-                    None,
-                )
-            }
-            None => {
-                // Create the callee. This is a fn ptr or zero-sized and hence a kind of scalar.
-                let callee = self.codegen_operand(bx, func);
-
-                let sig = callee.layout.ty.fn_sig(bx.tcx());
-
-                match *callee.layout.ty.kind() {
-                    ty::FnDef(def_id, substs) => (
-                        sig,
-                        Some(
-                            ty::Instance::expect_resolve(
-                                bx.tcx(),
-                                ty::ParamEnv::reveal_all(),
-                                def_id,
-                                substs,
-                            )
-                            .polymorphize(bx.tcx()),
-                        ),
-                        None,
-                    ),
-                    ty::FnPtr(_) => (sig, None, Some(callee.immediate())),
-                    _ => bug!("{} is not callable", callee.layout.ty),
-                }
-            }
+        let (instance, mut llfn) = match *callee.layout.ty.kind() {
+            ty::FnDef(def_id, substs) => (
+                Some(
+                    ty::Instance::expect_resolve(
+                        bx.tcx(),
+                        ty::ParamEnv::reveal_all(),
+                        def_id,
+                        substs,
+                    )
+                    .polymorphize(bx.tcx()),
+                ),
+                None,
+            ),
+            ty::FnPtr(_) => (None, Some(callee.immediate())),
+            _ => bug!("{} is not callable", callee.layout.ty),
         };
-
         let def = instance.map(|i| i.def);
 
         if let Some(ty::InstanceDef::DropGlue(_, None)) = def {
@@ -807,6 +773,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         // FIXME(eddyb) avoid computing this if possible, when `instance` is
         // available - right now `sig` is only needed for getting the `abi`
         // and figuring out how many extra args were passed to a C-variadic `fn`.
+        let sig = callee.layout.ty.fn_sig(bx.tcx());
         let abi = sig.abi();
 
         // Handle intrinsics old codegen wants Expr's for, ourselves.

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -1,15 +1,9 @@
 use crate::base;
 use crate::traits::*;
-use rustc_hir::def_id::DefId;
-use rustc_index::vec::Idx;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::ErrorHandled;
-use rustc_middle::mir::visit::MutVisitor;
-use rustc_middle::mir::visit::Visitor;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, TyAndLayout};
-use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
-use rustc_span::DUMMY_SP;
 use rustc_target::abi::call::{FnAbi, PassMode};
 
 use std::iter;
@@ -49,9 +43,6 @@ pub struct FunctionCx<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
 
     fn_abi: &'tcx FnAbi<'tcx, Ty<'tcx>>,
 
-    // Used to replace call terminators with a call to a thread local shim.
-    call_thread_local_shims: Vec<(mir::Operand<'tcx>, DefId)>,
-
     /// When unwinding is initiated, we have to store this personality
     /// value somewhere so that we can load it and re-use it in the
     /// resume instruction. The personality is (afaik) some kind of
@@ -151,112 +142,6 @@ impl<'a, 'tcx, V: CodegenObject> LocalRef<'tcx, V> {
     }
 }
 
-struct FindThreadLocal(bool);
-
-impl<'tcx> Visitor<'tcx> for FindThreadLocal {
-    fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: mir::Location) {
-        if let mir::Rvalue::ThreadLocalRef(..) = rvalue {
-            self.0 = true;
-        }
-        self.super_rvalue(rvalue, location);
-    }
-}
-
-struct ReplaceThreadLocal<'tcx> {
-    tcx: TyCtxt<'tcx>,
-    local_start: usize,
-    list: Vec<DefId>,
-}
-
-impl<'tcx> MutVisitor<'tcx> for ReplaceThreadLocal<'tcx> {
-    fn tcx(&self) -> TyCtxt<'tcx> {
-        self.tcx
-    }
-
-    fn visit_rvalue(&mut self, rvalue: &mut mir::Rvalue<'tcx>, location: mir::Location) {
-        if let mir::Rvalue::ThreadLocalRef(def_id) = *rvalue {
-            if !def_id.is_local() {
-                *rvalue = mir::Rvalue::Use(mir::Operand::Copy(mir::Place {
-                    local: mir::Local::new(self.local_start + self.list.len()),
-                    projection: self.tcx.intern_place_elems(&[]),
-                }));
-                self.list.push(def_id);
-            }
-        }
-        self.super_rvalue(rvalue, location);
-    }
-}
-
-// Convert thread local references to thread local function shims if necessary
-fn convert_tls_rvalues<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    mir: &mut &'tcx mir::Body<'tcx>,
-) -> Vec<(mir::Operand<'tcx>, DefId)> {
-    if tcx.sess.target.dll_tls_export {
-        // The target supports DLL TLS exports. We don't need to do anything
-        return Vec::new();
-    }
-
-    // Fast path to look for any thread locals
-    let mut visitor = FindThreadLocal(false);
-    visitor.visit_body(&mir);
-    if !visitor.0 {
-        return Vec::new();
-    }
-
-    // Don't modify shims
-    if let ty::InstanceDef::ThreadLocalShim(..) = mir.source.instance {
-        return Vec::new();
-    }
-
-    let mut result = Vec::new();
-    let mut body = mir.clone();
-
-    let mut visitor =
-        ReplaceThreadLocal { tcx, local_start: mir.local_decls.len(), list: Vec::new() };
-    visitor.visit_body(&mut body);
-
-    for (i, &def_id) in visitor.list.iter().enumerate() {
-        let ty = mir::Rvalue::ThreadLocalRef(def_id).ty(&IndexVec::new(), tcx);
-        body.local_decls.push(mir::LocalDecl::new(ty, DUMMY_SP));
-        let local = mir::Local::new(visitor.local_start + i);
-        let place = mir::Place { local, projection: tcx.intern_place_elems(&[]) };
-        let func = mir::Operand::Copy(place);
-
-        result.push((func.clone(), def_id));
-
-        let blocks = body.basic_blocks.as_mut();
-
-        let new_entry = mir::BasicBlock::new(blocks.len());
-
-        let entry = std::mem::replace(
-            &mut blocks[mir::BasicBlock::new(0)],
-            mir::BasicBlockData {
-                statements: Vec::new(),
-                terminator: Some(mir::Terminator {
-                    source_info: mir::SourceInfo::outermost(DUMMY_SP),
-                    kind: mir::TerminatorKind::Call {
-                        func,
-                        args: Vec::new(),
-                        destination: place,
-                        target: Some(new_entry),
-                        cleanup: None,
-                        from_hir_call: false,
-                        fn_span: DUMMY_SP,
-                    },
-                }),
-                is_cleanup: false,
-            },
-        );
-
-        blocks.push(entry);
-    }
-
-    *mir = tcx.arena.alloc(body);
-
-    result
-}
-
 ///////////////////////////////////////////////////////////////////////////
 
 #[instrument(level = "debug", skip(cx))]
@@ -268,9 +153,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     let llfn = cx.get_fn(instance);
 
-    let mut mir = cx.tcx().instance_mir(instance.def);
-
-    let call_thread_local_shims = convert_tls_rvalues(cx.tcx(), &mut mir);
+    let mir = cx.tcx().instance_mir(instance.def);
 
     let fn_abi = cx.fn_abi_of_instance(instance, ty::List::empty());
     debug!("fn_abi: {:?}", fn_abi);
@@ -300,7 +183,6 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         llfn,
         fn_abi,
         cx,
-        call_thread_local_shims,
         personality_slot: None,
         cached_llbbs,
         unreachable_block: None,

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -462,8 +462,19 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
             mir::Rvalue::ThreadLocalRef(def_id) => {
                 assert!(bx.cx().tcx().is_static(def_id));
-                let static_ = bx.get_static(def_id);
                 let layout = bx.layout_of(bx.cx().tcx().static_ptr_ty(def_id));
+                let static_ = if !def_id.is_local() && !bx.cx().tcx().sess.target.dll_tls_export {
+                    let instance = ty::Instance {
+                        def: ty::InstanceDef::ThreadLocalShim(def_id),
+                        substs: ty::InternalSubsts::empty(),
+                    };
+                    let fn_ptr = bx.get_fn_addr(instance);
+                    let fn_abi = bx.fn_abi_of_instance(instance, ty::List::empty());
+                    let fn_ty = bx.fn_decl_backend_type(&fn_abi);
+                    bx.call(fn_ty, Some(fn_abi), fn_ptr, &[], None)
+                } else {
+                    bx.get_static(def_id)
+                };
                 OperandRef { val: OperandValue::Immediate(static_), layout }
             }
             mir::Rvalue::Use(ref operand) => self.codegen_operand(bx, operand),