2 use table::{Table, TableBuilder};
4 use rustc::hir::exports::Export;
6 use rustc::middle::cstore::{DepKind, ForeignModule, LinkagePreference, NativeLibrary};
7 use rustc::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel};
8 use rustc::middle::lang_items;
10 use rustc::session::config::SymbolManglingVersion;
11 use rustc::session::CrateDisambiguator;
12 use rustc::ty::{self, ReprOptions, Ty};
13 use rustc_data_structures::svh::Svh;
14 use rustc_data_structures::sync::MetadataRef;
16 use rustc_hir::def::CtorKind;
17 use rustc_hir::def_id::{DefId, DefIndex};
18 use rustc_index::vec::IndexVec;
19 use rustc_serialize::opaque::Encoder;
20 use rustc_span::edition::Edition;
21 use rustc_span::symbol::Symbol;
22 use rustc_span::{self, Span};
23 use rustc_target::spec::{PanicStrategy, TargetTriple};
24 use syntax::{ast, attr};
26 use std::marker::PhantomData;
27 use std::num::NonZeroUsize;
29 pub use decoder::{provide, provide_extern};
30 crate use decoder::{CrateMetadata, CrateNumMap, MetadataBlob};
36 crate fn rustc_version() -> String {
37 format!("rustc {}", option_env!("CFG_VERSION").unwrap_or("unknown version"))
40 /// Metadata encoding version.
41 /// N.B., increment this if you change the format of metadata such that
42 /// the rustc version can't be found to compare with `rustc_version()`.
43 const METADATA_VERSION: u8 = 5;
45 /// Metadata header which includes `METADATA_VERSION`.
47 /// This header is followed by the position of the `CrateRoot`,
48 /// which is encoded as a 32-bit big-endian unsigned integer,
49 /// and further followed by the rustc version string.
50 crate const METADATA_HEADER: &[u8; 8] = &[b'r', b'u', b's', b't', 0, 0, 0, METADATA_VERSION];
52 /// Additional metadata for a `Lazy<T>` where `T` may not be `Sized`,
53 /// e.g. for `Lazy<[T]>`, this is the length (count of `T` values).
55 type Meta: Copy + 'static;
57 /// Returns the minimum encoded size.
58 // FIXME(eddyb) Give better estimates for certain types.
59 fn min_size(meta: Self::Meta) -> usize;
62 impl<T> LazyMeta for T {
65 fn min_size(_: ()) -> usize {
66 assert_ne!(std::mem::size_of::<T>(), 0);
71 impl<T> LazyMeta for [T] {
74 fn min_size(len: usize) -> usize {
79 /// A value of type T referred to by its absolute position
80 /// in the metadata, and which can be decoded lazily.
82 /// Metadata is effective a tree, encoded in post-order,
83 /// and with the root's position written next to the header.
84 /// That means every single `Lazy` points to some previous
85 /// location in the metadata and is part of a larger node.
87 /// The first `Lazy` in a node is encoded as the backwards
88 /// distance from the position where the containing node
89 /// starts and where the `Lazy` points to, while the rest
90 /// use the forward distance from the previous `Lazy`.
91 /// Distances start at 1, as 0-byte nodes are invalid.
92 /// Also invalid are nodes being referred in a different
93 /// order than they were encoded in.
95 /// # Sequences (`Lazy<[T]>`)
97 /// Unlike `Lazy<Vec<T>>`, the length is encoded next to the
98 /// position, not at the position, which means that the length
99 /// doesn't need to be known before encoding all the elements.
101 /// If the length is 0, no position is encoded, but otherwise,
102 /// the encoding is that of `Lazy`, with the distinction that
103 /// the minimal distance the length of the sequence, i.e.
104 /// it's assumed there's no 0-byte element in the sequence.
106 // FIXME(#59875) the `Meta` parameter only exists to dodge
107 // invariance wrt `T` (coming from the `meta: T::Meta` field).
108 struct Lazy<T, Meta = <T as LazyMeta>::Meta>
110 T: ?Sized + LazyMeta<Meta = Meta>,
111 Meta: 'static + Copy,
113 position: NonZeroUsize,
115 _marker: PhantomData<T>,
118 impl<T: ?Sized + LazyMeta> Lazy<T> {
119 fn from_position_and_meta(position: NonZeroUsize, meta: T::Meta) -> Lazy<T> {
120 Lazy { position, meta, _marker: PhantomData }
125 fn from_position(position: NonZeroUsize) -> Lazy<T> {
126 Lazy::from_position_and_meta(position, ())
131 fn empty() -> Lazy<[T]> {
132 Lazy::from_position_and_meta(NonZeroUsize::new(1).unwrap(), 0)
136 impl<T: ?Sized + LazyMeta> Copy for Lazy<T> {}
137 impl<T: ?Sized + LazyMeta> Clone for Lazy<T> {
138 fn clone(&self) -> Self {
143 impl<T: ?Sized + LazyMeta> rustc_serialize::UseSpecializedEncodable for Lazy<T> {}
144 impl<T: ?Sized + LazyMeta> rustc_serialize::UseSpecializedDecodable for Lazy<T> {}
146 /// Encoding / decoding state for `Lazy`.
147 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
149 /// Outside of a metadata node.
152 /// Inside a metadata node, and before any `Lazy`.
153 /// The position is that of the node itself.
154 NodeStart(NonZeroUsize),
156 /// Inside a metadata node, with a previous `Lazy`.
157 /// The position is a conservative estimate of where that
158 /// previous `Lazy` would end (see their comments).
159 Previous(NonZeroUsize),
162 // FIXME(#59875) `Lazy!(T)` replaces `Lazy<T>`, passing the `Meta` parameter
163 // manually, instead of relying on the default, to get the correct variance.
164 // Only needed when `T` itself contains a parameter (e.g. `'tcx`).
166 (Table<$I:ty, $T:ty>) => {Lazy<Table<$I, $T>, usize>};
167 ([$T:ty]) => {Lazy<[$T], usize>};
168 ($T:ty) => {Lazy<$T, ()>};
171 #[derive(RustcEncodable, RustcDecodable)]
172 crate struct CrateRoot<'tcx> {
174 triple: TargetTriple,
175 extra_filename: String,
177 disambiguator: CrateDisambiguator,
178 panic_strategy: PanicStrategy,
180 has_global_allocator: bool,
181 has_panic_handler: bool,
182 has_default_lib_allocator: bool,
183 plugin_registrar_fn: Option<DefIndex>,
184 proc_macro_decls_static: Option<DefIndex>,
185 proc_macro_stability: Option<attr::Stability>,
187 crate_deps: Lazy<[CrateDep]>,
188 dylib_dependency_formats: Lazy<[Option<LinkagePreference>]>,
189 lib_features: Lazy<[(Symbol, Option<Symbol>)]>,
190 lang_items: Lazy<[(DefIndex, usize)]>,
191 lang_items_missing: Lazy<[lang_items::LangItem]>,
192 diagnostic_items: Lazy<[(Symbol, DefIndex)]>,
193 native_libraries: Lazy<[NativeLibrary]>,
194 foreign_modules: Lazy<[ForeignModule]>,
195 source_map: Lazy<[rustc_span::SourceFile]>,
196 def_path_table: Lazy<map::definitions::DefPathTable>,
197 impls: Lazy<[TraitImpls]>,
198 exported_symbols: Lazy!([(ExportedSymbol<'tcx>, SymbolExportLevel)]),
199 interpret_alloc_index: Lazy<[u32]>,
201 per_def: LazyPerDefTables<'tcx>,
203 /// The DefIndex's of any proc macros delcared by this crate.
204 proc_macro_data: Option<Lazy<[DefIndex]>>,
206 compiler_builtins: bool,
207 needs_allocator: bool,
208 needs_panic_runtime: bool,
211 profiler_runtime: bool,
212 symbol_mangling_version: SymbolManglingVersion,
215 #[derive(RustcEncodable, RustcDecodable)]
216 crate struct CrateDep {
219 pub host_hash: Option<Svh>,
221 pub extra_filename: String,
224 #[derive(RustcEncodable, RustcDecodable)]
225 crate struct TraitImpls {
226 trait_id: (u32, DefIndex),
227 impls: Lazy<[DefIndex]>,
230 /// Define `LazyPerDefTables` and `PerDefTableBuilders` at the same time.
231 macro_rules! define_per_def_tables {
232 ($($name:ident: Table<DefIndex, $T:ty>),+ $(,)?) => {
233 #[derive(RustcEncodable, RustcDecodable)]
234 crate struct LazyPerDefTables<'tcx> {
235 $($name: Lazy!(Table<DefIndex, $T>)),+
239 struct PerDefTableBuilders<'tcx> {
240 $($name: TableBuilder<DefIndex, $T>),+
243 impl PerDefTableBuilders<'tcx> {
244 fn encode(&self, buf: &mut Encoder) -> LazyPerDefTables<'tcx> {
246 $($name: self.$name.encode(buf)),+
253 define_per_def_tables! {
254 kind: Table<DefIndex, Lazy!(EntryKind<'tcx>)>,
255 visibility: Table<DefIndex, Lazy<ty::Visibility>>,
256 span: Table<DefIndex, Lazy<Span>>,
257 attributes: Table<DefIndex, Lazy<[ast::Attribute]>>,
258 children: Table<DefIndex, Lazy<[DefIndex]>>,
259 stability: Table<DefIndex, Lazy<attr::Stability>>,
260 const_stability: Table<DefIndex, Lazy<attr::ConstStability>>,
261 deprecation: Table<DefIndex, Lazy<attr::Deprecation>>,
262 ty: Table<DefIndex, Lazy!(Ty<'tcx>)>,
263 fn_sig: Table<DefIndex, Lazy!(ty::PolyFnSig<'tcx>)>,
264 impl_trait_ref: Table<DefIndex, Lazy!(ty::TraitRef<'tcx>)>,
265 inherent_impls: Table<DefIndex, Lazy<[DefIndex]>>,
266 variances: Table<DefIndex, Lazy<[ty::Variance]>>,
267 generics: Table<DefIndex, Lazy<ty::Generics>>,
268 explicit_predicates: Table<DefIndex, Lazy!(ty::GenericPredicates<'tcx>)>,
269 // FIXME(eddyb) this would ideally be `Lazy<[...]>` but `ty::Predicate`
270 // doesn't handle shorthands in its own (de)serialization impls,
271 // as it's an `enum` for which we want to derive (de)serialization,
272 // so the `ty::codec` APIs handle the whole `&'tcx [...]` at once.
273 // Also, as an optimization, a missing entry indicates an empty `&[]`.
274 inferred_outlives: Table<DefIndex, Lazy!(&'tcx [(ty::Predicate<'tcx>, Span)])>,
275 super_predicates: Table<DefIndex, Lazy!(ty::GenericPredicates<'tcx>)>,
276 mir: Table<DefIndex, Lazy!(mir::BodyAndCache<'tcx>)>,
277 promoted_mir: Table<DefIndex, Lazy!(IndexVec<mir::Promoted, mir::BodyAndCache<'tcx>>)>,
280 #[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
281 enum EntryKind<'tcx> {
282 Const(mir::ConstQualifs, Lazy<RenderedConst>),
296 Variant(Lazy<VariantData>),
297 Struct(Lazy<VariantData>, ReprOptions),
298 Union(Lazy<VariantData>, ReprOptions),
300 ForeignFn(Lazy<FnData>),
302 MacroDef(Lazy<MacroDef>),
304 Generator(Lazy!(GeneratorData<'tcx>)),
305 Trait(Lazy<TraitData>),
306 Impl(Lazy<ImplData>),
307 Method(Lazy<MethodData>),
308 AssocType(AssocContainer),
309 AssocOpaqueTy(AssocContainer),
310 AssocConst(AssocContainer, mir::ConstQualifs, Lazy<RenderedConst>),
314 /// Contains a constant which has been rendered to a String.
316 #[derive(RustcEncodable, RustcDecodable)]
317 struct RenderedConst(String);
319 #[derive(RustcEncodable, RustcDecodable)]
321 reexports: Lazy<[Export<hir::HirId>]>,
324 #[derive(RustcEncodable, RustcDecodable)]
330 #[derive(RustcEncodable, RustcDecodable)]
332 asyncness: hir::IsAsync,
333 constness: hir::Constness,
334 param_names: Lazy<[ast::Name]>,
337 #[derive(RustcEncodable, RustcDecodable)]
340 discr: ty::VariantDiscr,
341 /// If this is unit or tuple-variant/struct, then this is the index of the ctor id.
342 ctor: Option<DefIndex>,
345 #[derive(RustcEncodable, RustcDecodable)]
347 unsafety: hir::Unsafety,
353 #[derive(RustcEncodable, RustcDecodable)]
355 polarity: ty::ImplPolarity,
356 defaultness: hir::Defaultness,
357 parent_impl: Option<DefId>,
359 /// This is `Some` only for impls of `CoerceUnsized`.
360 // FIXME(eddyb) perhaps compute this on the fly if cheap enough?
361 coerce_unsized_info: Option<ty::adjustment::CoerceUnsizedInfo>,
364 /// Describes whether the container of an associated item
365 /// is a trait or an impl and whether, in a trait, it has
366 /// a default, or an in impl, whether it's marked "default".
367 #[derive(Copy, Clone, RustcEncodable, RustcDecodable)]
368 enum AssocContainer {
375 impl AssocContainer {
376 fn with_def_id(&self, def_id: DefId) -> ty::AssocItemContainer {
378 AssocContainer::TraitRequired | AssocContainer::TraitWithDefault => {
379 ty::TraitContainer(def_id)
382 AssocContainer::ImplDefault | AssocContainer::ImplFinal => ty::ImplContainer(def_id),
386 fn defaultness(&self) -> hir::Defaultness {
388 AssocContainer::TraitRequired => hir::Defaultness::Default { has_value: false },
390 AssocContainer::TraitWithDefault | AssocContainer::ImplDefault => {
391 hir::Defaultness::Default { has_value: true }
394 AssocContainer::ImplFinal => hir::Defaultness::Final,
399 #[derive(RustcEncodable, RustcDecodable)]
402 container: AssocContainer,
406 #[derive(RustcEncodable, RustcDecodable)]
407 struct GeneratorData<'tcx> {
408 layout: mir::GeneratorLayout<'tcx>,
411 // Tags used for encoding Spans:
412 const TAG_VALID_SPAN: u8 = 0;
413 const TAG_INVALID_SPAN: u8 = 1;