Measure upper limit for performance of 32 bit Span

Author: petrochenkov

src/librustc_data_structures/sync.rs

@@ -517,7 +517,7 @@ impl<T> Once<T> {
 }
 
 #[derive(Debug)]
-pub struct Lock<T>(InnerLock<T>);
+pub struct Lock<T>(pub InnerLock<T>);
 
 impl<T> Lock<T> {
     #[inline(always)]

src/libsyntax/lib.rs

@@ -98,7 +98,11 @@ pub fn with_globals<F, R>(f: F) -> R
 {
     let globals = Globals::new();
     GLOBALS.set(&globals, || {
-        syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, f)
+        syntax_pos::GLOBALS.set(&globals.syntax_pos_globals, unsafe {
+            syntax_pos::SPAN_INTERNER_BACKDOOR =
+                globals.syntax_pos_globals.span_interner.0.as_ptr();
+            f
+        })
     })
 }
 

src/libsyntax_pos/lib.rs

@@ -18,6 +18,7 @@
 #![feature(rustc_attrs)]
 #![feature(specialization)]
 #![feature(step_trait)]
+#![feature(stmt_expr_attributes)]
 
 use serialize::{Encodable, Decodable, Encoder, Decoder};
 
@@ -29,7 +30,7 @@ pub mod hygiene;
 pub use hygiene::{Mark, SyntaxContext, ExpnInfo, ExpnFormat, CompilerDesugaringKind};
 
 mod span_encoding;
-pub use span_encoding::{Span, DUMMY_SP};
+pub use span_encoding::{Span, DUMMY_SP, SPAN_INTERNER_BACKDOOR};
 
 pub mod symbol;
 
@@ -48,7 +49,7 @@ use std::path::PathBuf;
 
 pub struct Globals {
     symbol_interner: Lock<symbol::Interner>,
-    span_interner: Lock<span_encoding::SpanInterner>,
+    pub span_interner: Lock<span_encoding::SpanInterner>,
     hygiene_data: Lock<hygiene::HygieneData>,
 }
 

src/libsyntax_pos/span_encoding.rs

@@ -4,12 +4,10 @@
 // The encoding format for inline spans were obtained by optimizing over crates in rustc/libstd.
 // See https://internals.rust-lang.org/t/rfc-compiler-refactoring-spans/1357/28
 
-use crate::GLOBALS;
 use crate::{BytePos, SpanData};
 use crate::hygiene::SyntaxContext;
 
 use rustc_data_structures::fx::FxHashMap;
-use std::hash::{Hash, Hasher};
 
 /// A compressed span.
 /// Contains either fields of `SpanData` inline if they are small, or index into span interner.
@@ -74,7 +72,7 @@ fn encode(sd: &SpanData) -> Span {
         (base << INLINE_OFFSETS[BASE_INDEX]) | (len << INLINE_OFFSETS[LEN_INDEX]) |
         (ctxt << INLINE_OFFSETS[CTXT_INDEX]) | TAG_INLINE
     } else {
-        let index = with_span_interner(|interner| interner.intern(sd));
+        let index = unsafe { (*SPAN_INTERNER_BACKDOOR).intern(sd) };
         (index << INTERNED_INDEX_OFFSET) | TAG_INTERNED
     };
     Span(val)
@@ -96,7 +94,7 @@ fn decode(span: Span) -> SpanData {
         extract(INLINE_OFFSETS[CTXT_INDEX], INLINE_SIZES[CTXT_INDEX]),
     )} else {
         let index = extract(INTERNED_INDEX_OFFSET, INTERNED_INDEX_SIZE);
-        return with_span_interner(|interner| *interner.get(index));
+        return unsafe { *(*SPAN_INTERNER_BACKDOOR).get(index) };
     };
     SpanData { lo: BytePos(base), hi: BytePos(base + len), ctxt: SyntaxContext::from_u32(ctxt) }
 }
@@ -125,8 +123,4 @@ impl SpanInterner {
     }
 }
 
-// If an interner exists, return it. Otherwise, prepare a fresh one.
-#[inline]
-fn with_span_interner<T, F: FnOnce(&mut SpanInterner) -> T>(f: F) -> T {
-    GLOBALS.with(|globals| f(&mut *globals.span_interner.lock()))
-}
+pub static mut SPAN_INTERNER_BACKDOOR: *mut SpanInterner = std::ptr::null_mut();