Rollup merge of #73033 - Amanieu:asm-tls, r=oli-obk

Dylan-DPC · web-flow · commit 2e4247626701 · 2020-06-12T00:05:19.000+02:00
Fix #[thread_local] statics as asm! sym operands The `asm!` RFC specifies that `#[thread_local]` statics may be used as `sym` operands for inline assembly. This also fixes a regression in the handling of `#[thread_local]` during monomorphization which caused link-time errors with multiple codegen units, most likely introduced by #71192. r? @oli-obk
diff --git a/src/librustc_codegen_ssa/mir/block.rs b/src/librustc_codegen_ssa/mir/block.rs
@@ -927,12 +927,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         span_bug!(span, "invalid type for asm sym (fn)");
                     }
                 }
-                mir::InlineAsmOperand::SymStatic { ref value } => {
-                    if let Some(def_id) = value.check_static_ptr(bx.tcx()) {
-                        InlineAsmOperandRef::SymStatic { def_id }
-                    } else {
-                        span_bug!(span, "invalid type for asm sym (static)");
-                    }
+                mir::InlineAsmOperand::SymStatic { def_id } => {
+                    InlineAsmOperandRef::SymStatic { def_id }
                 }
             })
             .collect();
diff --git a/src/librustc_middle/mir/mod.rs b/src/librustc_middle/mir/mod.rs
@@ -1243,7 +1243,7 @@ pub enum InlineAsmOperand<'tcx> {
         value: Box<Constant<'tcx>>,
     },
     SymStatic {
-        value: Box<Constant<'tcx>>,
+        def_id: DefId,
     },
 }
 
@@ -1639,9 +1639,11 @@ impl<'tcx> TerminatorKind<'tcx> {
                         InlineAsmOperand::Const { value } => {
                             write!(fmt, "const {:?}", value)?;
                         }
-                        InlineAsmOperand::SymFn { value }
-                        | InlineAsmOperand::SymStatic { value } => {
-                            write!(fmt, "sym {:?}", value)?;
+                        InlineAsmOperand::SymFn { value } => {
+                            write!(fmt, "sym_fn {:?}", value)?;
+                        }
+                        InlineAsmOperand::SymStatic { def_id } => {
+                            write!(fmt, "sym_static {:?}", def_id)?;
                         }
                     }
                 }
diff --git a/src/librustc_middle/mir/visit.rs b/src/librustc_middle/mir/visit.rs
@@ -564,10 +564,10 @@ macro_rules! make_mir_visitor {
                                         );
                                     }
                                 }
-                                InlineAsmOperand::SymFn { value }
-                                | InlineAsmOperand::SymStatic { value } => {
+                                InlineAsmOperand::SymFn { value } => {
                                     self.visit_constant(value, source_location);
                                 }
+                                InlineAsmOperand::SymStatic { def_id: _ } => {}
                             }
                         }
                     }
diff --git a/src/librustc_mir/borrow_check/invalidation.rs b/src/librustc_mir/borrow_check/invalidation.rs
@@ -209,7 +209,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {
                             }
                         }
                         InlineAsmOperand::SymFn { value: _ }
-                        | InlineAsmOperand::SymStatic { value: _ } => {}
+                        | InlineAsmOperand::SymStatic { def_id: _ } => {}
                     }
                 }
             }
diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs
@@ -760,7 +760,7 @@ impl<'cx, 'tcx> dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tc
                             }
                         }
                         InlineAsmOperand::SymFn { value: _ }
-                        | InlineAsmOperand::SymStatic { value: _ } => {}
+                        | InlineAsmOperand::SymStatic { def_id: _ } => {}
                     }
                 }
             }
diff --git a/src/librustc_mir/dataflow/move_paths/builder.rs b/src/librustc_mir/dataflow/move_paths/builder.rs
@@ -439,7 +439,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {
                             }
                         }
                         InlineAsmOperand::SymFn { value: _ }
-                        | InlineAsmOperand::SymStatic { value: _ } => {}
+                        | InlineAsmOperand::SymStatic { def_id: _ } => {}
                     }
                 }
             }
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
@@ -634,9 +634,19 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {
             }
             mir::TerminatorKind::InlineAsm { ref operands, .. } => {
                 for op in operands {
-                    if let mir::InlineAsmOperand::SymFn { value } = op {
-                        let fn_ty = self.monomorphize(value.literal.ty);
-                        visit_fn_use(self.tcx, fn_ty, false, &mut self.output);
+                    match *op {
+                        mir::InlineAsmOperand::SymFn { ref value } => {
+                            let fn_ty = self.monomorphize(value.literal.ty);
+                            visit_fn_use(self.tcx, fn_ty, false, &mut self.output);
+                        }
+                        mir::InlineAsmOperand::SymStatic { def_id } => {
+                            let instance = Instance::mono(self.tcx, def_id);
+                            if should_monomorphize_locally(self.tcx, &instance) {
+                                trace!("collecting asm sym static {:?}", def_id);
+                                self.output.push(MonoItem::Static(def_id));
+                            }
+                        }
+                        _ => {}
                     }
                 }
             }
diff --git a/src/librustc_mir_build/build/expr/into.rs b/src/librustc_mir_build/build/expr/into.rs
@@ -358,8 +358,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                         hair::InlineAsmOperand::SymFn { expr } => {
                             mir::InlineAsmOperand::SymFn { value: box this.as_constant(expr) }
                         }
-                        hair::InlineAsmOperand::SymStatic { expr } => {
-                            mir::InlineAsmOperand::SymStatic { value: box this.as_constant(expr) }
+                        hair::InlineAsmOperand::SymStatic { def_id } => {
+                            mir::InlineAsmOperand::SymStatic { def_id }
                         }
                     })
                     .collect();
diff --git a/src/librustc_mir_build/hair/cx/expr.rs b/src/librustc_mir_build/hair/cx/expr.rs
@@ -467,25 +467,8 @@ fn make_mirror_unadjusted<'a, 'tcx>(
                                     }
                                 }
 
-                                Res::Def(DefKind::Static, id) => {
-                                    ty = cx.tcx.static_ptr_ty(id);
-                                    let ptr = cx.tcx.create_static_alloc(id);
-                                    InlineAsmOperand::SymStatic {
-                                        expr: Expr {
-                                            ty,
-                                            temp_lifetime,
-                                            span: expr.span,
-                                            kind: ExprKind::StaticRef {
-                                                literal: ty::Const::from_scalar(
-                                                    cx.tcx,
-                                                    Scalar::Ptr(ptr.into()),
-                                                    ty,
-                                                ),
-                                                def_id: id,
-                                            },
-                                        }
-                                        .to_ref(),
-                                    }
+                                Res::Def(DefKind::Static, def_id) => {
+                                    InlineAsmOperand::SymStatic { def_id }
                                 }
 
                                 _ => {
diff --git a/src/librustc_mir_build/hair/mod.rs b/src/librustc_mir_build/hair/mod.rs
@@ -377,7 +377,7 @@ crate enum InlineAsmOperand<'tcx> {
         expr: ExprRef<'tcx>,
     },
     SymStatic {
-        expr: ExprRef<'tcx>,
+        def_id: DefId,
     },
 }
 
diff --git a/src/test/ui/asm/sym.rs b/src/test/ui/asm/sym.rs
@@ -1,8 +1,9 @@
 // no-system-llvm
 // only-x86_64
+// only-linux
 // run-pass
 
-#![feature(asm, track_caller)]
+#![feature(asm, track_caller, thread_local)]
 
 extern "C" fn f1() -> i32 {
     111
@@ -15,9 +16,9 @@ fn f2() -> i32 {
 }
 
 macro_rules! call {
-    ($func:path) => {{
-        let result: i32;
+    ($func:path) => {
         unsafe {
+            let result: i32;
             asm!("call {}", sym $func,
                 out("rax") result,
                 out("rcx") _, out("rdx") _, out("rdi") _, out("rsi") _,
@@ -27,12 +28,53 @@ macro_rules! call {
                 out("xmm8") _, out("xmm9") _, out("xmm10") _, out("xmm11") _,
                 out("xmm12") _, out("xmm13") _, out("xmm14") _, out("xmm15") _,
             );
+            result
         }
-        result
-    }}
+    }
 }
 
+macro_rules! static_addr {
+    ($s:expr) => {
+        unsafe {
+            let result: *const u32;
+            // LEA performs a RIP-relative address calculation and returns the address
+            asm!("lea {}, [rip + {}]", out(reg) result, sym $s);
+            result
+        }
+    }
+}
+macro_rules! static_tls_addr {
+    ($s:expr) => {
+        unsafe {
+            let result: *const u32;
+            asm!(
+                "
+                    # Load TLS base address
+                    mov {out}, qword ptr fs:[0]
+                    # Calculate the address of sym in the TLS block. The @tpoff
+                    # relocation gives the offset of the symbol from the start
+                    # of the TLS block.
+                    lea {out}, [{out} + {sym}@tpoff]
+                ",
+                out = out(reg) result,
+                sym = sym $s
+            );
+            result
+        }
+    }
+}
+
+static S1: u32 = 111;
+#[thread_local]
+static S2: u32 = 222;
+
 fn main() {
     assert_eq!(call!(f1), 111);
     assert_eq!(call!(f2), 222);
+    assert_eq!(static_addr!(S1), &S1 as *const u32);
+    assert_eq!(static_tls_addr!(S2), &S2 as *const u32);
+    std::thread::spawn(|| {
+        assert_eq!(static_addr!(S1), &S1 as *const u32);
+        assert_eq!(static_tls_addr!(S2), &S2 as *const u32);
+    });
 }

Original file line number	Diff line number	Diff line change
`@@ -927,12 +927,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {`
`927`	`927`	`span_bug!(span, "invalid type for asm sym (fn)");`
`928`	`928`	`}`
`929`	`929`	`}`
`930`		`- mir::InlineAsmOperand::SymStatic { ref value } => {`
`931`		`- if let Some(def_id) = value.check_static_ptr(bx.tcx()) {`
`932`		`- InlineAsmOperandRef::SymStatic { def_id }`
`933`		`- } else {`
`934`		`- span_bug!(span, "invalid type for asm sym (static)");`
`935`		`- }`
	`930`	`+ mir::InlineAsmOperand::SymStatic { def_id } => {`
	`931`	`+ InlineAsmOperandRef::SymStatic { def_id }`
`936`	`932`	`}`
`937`	`933`	`})`
`938`	`934`	`.collect();`
Original file line number	Diff line number	Diff line change
`@@ -1243,7 +1243,7 @@ pub enum InlineAsmOperand<'tcx> {`
`1243`	`1243`	`value: Box<Constant<'tcx>>,`
`1244`	`1244`	`},`
`1245`	`1245`	`SymStatic {`
`1246`		`- value: Box<Constant<'tcx>>,`
	`1246`	`+ def_id: DefId,`
`1247`	`1247`	`},`
`1248`	`1248`	`}`
`1249`	`1249`
`@@ -1639,9 +1639,11 @@ impl<'tcx> TerminatorKind<'tcx> {`
`1639`	`1639`	`InlineAsmOperand::Const { value } => {`
`1640`	`1640`	`write!(fmt, "const {:?}", value)?;`
`1641`	`1641`	`}`
`1642`		`- InlineAsmOperand::SymFn { value }`
`1643`		`- \| InlineAsmOperand::SymStatic { value } => {`
`1644`		`- write!(fmt, "sym {:?}", value)?;`
	`1642`	`+ InlineAsmOperand::SymFn { value } => {`
	`1643`	`+ write!(fmt, "sym_fn {:?}", value)?;`
	`1644`	`+ }`
	`1645`	`+ InlineAsmOperand::SymStatic { def_id } => {`
	`1646`	`+ write!(fmt, "sym_static {:?}", def_id)?;`
`1645`	`1647`	`}`
`1646`	`1648`	`}`
`1647`	`1649`	`}`
Original file line number	Diff line number	Diff line change
`@@ -564,10 +564,10 @@ macro_rules! make_mir_visitor {`
`564`	`564`	`);`
`565`	`565`	`}`
`566`	`566`	`}`
`567`		`- InlineAsmOperand::SymFn { value }`
`568`		`- \| InlineAsmOperand::SymStatic { value } => {`
	`567`	`+ InlineAsmOperand::SymFn { value } => {`
`569`	`568`	`self.visit_constant(value, source_location);`
`570`	`569`	`}`
	`570`	`+ InlineAsmOperand::SymStatic { def_id: _ } => {}`
`571`	`571`	`}`
`572`	`572`	`}`
`573`	`573`	`}`
Original file line number	Diff line number	Diff line change
`@@ -209,7 +209,7 @@ impl<'cx, 'tcx> Visitor<'tcx> for InvalidationGenerator<'cx, 'tcx> {`
`209`	`209`	`}`
`210`	`210`	`}`
`211`	`211`	`InlineAsmOperand::SymFn { value: _ }`
`212`		`- \| InlineAsmOperand::SymStatic { value: _ } => {}`
	`212`	`+ \| InlineAsmOperand::SymStatic { def_id: _ } => {}`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`	`}`
Original file line number	Diff line number	Diff line change
`@@ -760,7 +760,7 @@ impl<'cx, 'tcx> dataflow::ResultsVisitor<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tc`
`760`	`760`	`}`
`761`	`761`	`}`
`762`	`762`	`InlineAsmOperand::SymFn { value: _ }`
`763`		`- \| InlineAsmOperand::SymStatic { value: _ } => {}`
	`763`	`+ \| InlineAsmOperand::SymStatic { def_id: _ } => {}`
`764`	`764`	`}`
`765`	`765`	`}`
`766`	`766`	`}`
Original file line number	Diff line number	Diff line change
`@@ -439,7 +439,7 @@ impl<'b, 'a, 'tcx> Gatherer<'b, 'a, 'tcx> {`
`439`	`439`	`}`
`440`	`440`	`}`
`441`	`441`	`InlineAsmOperand::SymFn { value: _ }`
`442`		`- \| InlineAsmOperand::SymStatic { value: _ } => {}`
	`442`	`+ \| InlineAsmOperand::SymStatic { def_id: _ } => {}`
`443`	`443`	`}`
`444`	`444`	`}`
`445`	`445`	`}`
Original file line number	Diff line number	Diff line change
`@@ -634,9 +634,19 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirNeighborCollector<'a, 'tcx> {`
`634`	`634`	`}`
`635`	`635`	`mir::TerminatorKind::InlineAsm { ref operands, .. } => {`
`636`	`636`	`for op in operands {`
`637`		`- if let mir::InlineAsmOperand::SymFn { value } = op {`
`638`		`- let fn_ty = self.monomorphize(value.literal.ty);`
`639`		`- visit_fn_use(self.tcx, fn_ty, false, &mut self.output);`
	`637`	`+ match *op {`
	`638`	`+ mir::InlineAsmOperand::SymFn { ref value } => {`
	`639`	`+ let fn_ty = self.monomorphize(value.literal.ty);`
	`640`	`+ visit_fn_use(self.tcx, fn_ty, false, &mut self.output);`
	`641`	`+ }`
	`642`	`+ mir::InlineAsmOperand::SymStatic { def_id } => {`
	`643`	`+ let instance = Instance::mono(self.tcx, def_id);`
	`644`	`+ if should_monomorphize_locally(self.tcx, &instance) {`
	`645`	`+ trace!("collecting asm sym static {:?}", def_id);`
	`646`	`+ self.output.push(MonoItem::Static(def_id));`
	`647`	`+ }`
	`648`	`+ }`
	`649`	`+ _ => {}`
`640`	`650`	`}`
`641`	`651`	`}`
`642`	`652`	`}`
Original file line number	Diff line number	Diff line change
`@@ -358,8 +358,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`358`	`358`	`hair::InlineAsmOperand::SymFn { expr } => {`
`359`	`359`	`mir::InlineAsmOperand::SymFn { value: box this.as_constant(expr) }`
`360`	`360`	`}`
`361`		`- hair::InlineAsmOperand::SymStatic { expr } => {`
`362`		`- mir::InlineAsmOperand::SymStatic { value: box this.as_constant(expr) }`
	`361`	`+ hair::InlineAsmOperand::SymStatic { def_id } => {`
	`362`	`+ mir::InlineAsmOperand::SymStatic { def_id }`
`363`	`363`	`}`
`364`	`364`	`})`
`365`	`365`	`.collect();`
Original file line number	Diff line number	Diff line change
`@@ -377,7 +377,7 @@ crate enum InlineAsmOperand<'tcx> {`
`377`	`377`	`expr: ExprRef<'tcx>,`
`378`	`378`	`},`
`379`	`379`	`SymStatic {`
`380`		`- expr: ExprRef<'tcx>,`
	`380`	`+ def_id: DefId,`
`381`	`381`	`},`
`382`	`382`	`}`
`383`	`383`