mirror of
https://github.com/rust-lang/rust.git
synced 2024-11-22 06:44:35 +00:00
make rustc_target usable outside of rustc
This commit is contained in:
parent
1dda298ad3
commit
09a384643e
@ -7,6 +7,10 @@ edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
arrayvec = { version = "0.7", default-features = false }
|
||||
rustc_serialize = { path = "../rustc_serialize" }
|
||||
rustc_macros = { path = "../rustc_macros" }
|
||||
rustc_serialize = { path = "../rustc_serialize", optional = true }
|
||||
rustc_macros = { path = "../rustc_macros", optional = true }
|
||||
smallvec = "1.8.1"
|
||||
|
||||
[features]
|
||||
default = ["nightly"]
|
||||
nightly = ["rustc_serialize", "rustc_macros"]
|
||||
|
@ -1,17 +1,20 @@
|
||||
#![deny(rustc::untranslatable_diagnostic)]
|
||||
#![deny(rustc::diagnostic_outside_of_impl)]
|
||||
#![feature(allow_internal_unstable)]
|
||||
#![feature(extend_one)]
|
||||
#![feature(min_specialization)]
|
||||
#![feature(new_uninit)]
|
||||
#![feature(step_trait)]
|
||||
#![feature(stmt_expr_attributes)]
|
||||
#![feature(test)]
|
||||
#![cfg_attr(feature = "nightly", feature(allow_internal_unstable))]
|
||||
#![cfg_attr(feature = "nightly", feature(extend_one))]
|
||||
#![cfg_attr(feature = "nightly", feature(min_specialization))]
|
||||
#![cfg_attr(feature = "nightly", feature(new_uninit))]
|
||||
#![cfg_attr(feature = "nightly", feature(step_trait))]
|
||||
#![cfg_attr(feature = "nightly", feature(stmt_expr_attributes))]
|
||||
#![cfg_attr(feature = "nightly", feature(test))]
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
pub mod bit_set;
|
||||
#[cfg(feature = "nightly")]
|
||||
pub mod interval;
|
||||
pub mod vec;
|
||||
|
||||
#[cfg(feature = "rustc_macros")]
|
||||
pub use rustc_macros::newtype_index;
|
||||
|
||||
/// Type size assertion. The first argument is a type and the second argument is its expected size.
|
||||
|
@ -1,3 +1,4 @@
|
||||
#[cfg(feature = "rustc_serialize")]
|
||||
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
|
||||
|
||||
use std::fmt;
|
||||
@ -61,12 +62,14 @@ pub struct IndexVec<I: Idx, T> {
|
||||
// not the phantom data.
|
||||
unsafe impl<I: Idx, T> Send for IndexVec<I, T> where T: Send {}
|
||||
|
||||
#[cfg(feature = "rustc_serialize")]
|
||||
impl<S: Encoder, I: Idx, T: Encodable<S>> Encodable<S> for IndexVec<I, T> {
|
||||
fn encode(&self, s: &mut S) {
|
||||
Encodable::encode(&self.raw, s);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "rustc_serialize")]
|
||||
impl<D: Decoder, I: Idx, T: Decodable<D>> Decodable<D> for IndexVec<I, T> {
|
||||
fn decode(d: &mut D) -> Self {
|
||||
IndexVec { raw: Decodable::decode(d), _marker: PhantomData }
|
||||
@ -359,11 +362,13 @@ impl<I: Idx, T> Extend<T> for IndexVec<I, T> {
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[cfg(feature = "nightly")]
|
||||
fn extend_one(&mut self, item: T) {
|
||||
self.raw.push(item);
|
||||
}
|
||||
|
||||
#[inline]
|
||||
#[cfg(feature = "nightly")]
|
||||
fn extend_reserve(&mut self, additional: usize) {
|
||||
self.raw.reserve(additional);
|
||||
}
|
||||
|
@ -6,7 +6,7 @@
|
||||
macro_rules! arena_types {
|
||||
($macro:path) => (
|
||||
$macro!([
|
||||
[] layout: rustc_target::abi::LayoutS<'tcx>,
|
||||
[] layout: rustc_target::abi::LayoutS<rustc_target::abi::VariantIdx>,
|
||||
[] fn_abi: rustc_target::abi::call::FnAbi<'tcx, rustc_middle::ty::Ty<'tcx>>,
|
||||
// AdtDef are interned and compared by address
|
||||
[decode] adt_def: rustc_middle::ty::AdtDefData,
|
||||
|
@ -148,7 +148,7 @@ pub struct CtxtInterners<'tcx> {
|
||||
const_: InternedSet<'tcx, ConstS<'tcx>>,
|
||||
const_allocation: InternedSet<'tcx, Allocation>,
|
||||
bound_variable_kinds: InternedSet<'tcx, List<ty::BoundVariableKind>>,
|
||||
layout: InternedSet<'tcx, LayoutS<'tcx>>,
|
||||
layout: InternedSet<'tcx, LayoutS<VariantIdx>>,
|
||||
adt_def: InternedSet<'tcx, AdtDefData>,
|
||||
}
|
||||
|
||||
@ -2244,7 +2244,7 @@ direct_interners! {
|
||||
region: mk_region(RegionKind<'tcx>): Region -> Region<'tcx>,
|
||||
const_: mk_const_internal(ConstS<'tcx>): Const -> Const<'tcx>,
|
||||
const_allocation: intern_const_alloc(Allocation): ConstAllocation -> ConstAllocation<'tcx>,
|
||||
layout: intern_layout(LayoutS<'tcx>): Layout -> Layout<'tcx>,
|
||||
layout: intern_layout(LayoutS<VariantIdx>): Layout -> Layout<'tcx>,
|
||||
adt_def: intern_adt_def(AdtDefData): AdtDef -> AdtDef<'tcx>,
|
||||
}
|
||||
|
||||
|
@ -610,7 +610,7 @@ where
|
||||
})
|
||||
}
|
||||
|
||||
Variants::Multiple { ref variants, .. } => variants[variant_index],
|
||||
Variants::Multiple { ref variants, .. } => cx.tcx().intern_layout(variants[variant_index].clone()),
|
||||
};
|
||||
|
||||
assert_eq!(*layout.variants(), Variants::Single { index: variant_index });
|
||||
|
@ -7,9 +7,20 @@ edition = "2021"
|
||||
bitflags = "1.2.1"
|
||||
tracing = "0.1"
|
||||
serde_json = "1.0.59"
|
||||
rustc_data_structures = { path = "../rustc_data_structures" }
|
||||
rustc_feature = { path = "../rustc_feature" }
|
||||
rustc_index = { path = "../rustc_index" }
|
||||
rustc_macros = { path = "../rustc_macros" }
|
||||
rustc_serialize = { path = "../rustc_serialize" }
|
||||
rustc_span = { path = "../rustc_span" }
|
||||
rustc_data_structures = { path = "../rustc_data_structures", optional = true }
|
||||
rustc_feature = { path = "../rustc_feature", optional = true }
|
||||
rustc_index = { path = "../rustc_index", default-features = false }
|
||||
rustc_macros = { path = "../rustc_macros", optional = true }
|
||||
rustc_serialize = { path = "../rustc_serialize", optional = true }
|
||||
rustc_span = { path = "../rustc_span", optional = true }
|
||||
|
||||
[features]
|
||||
default = ["nightly"]
|
||||
nightly = [
|
||||
"rustc_data_structures",
|
||||
"rustc_feature",
|
||||
"rustc_index/nightly",
|
||||
"rustc_macros",
|
||||
"rustc_serialize",
|
||||
"rustc_span",
|
||||
]
|
@ -2,23 +2,29 @@ pub use Integer::*;
|
||||
pub use Primitive::*;
|
||||
|
||||
use crate::json::{Json, ToJson};
|
||||
#[cfg(feature = "nightly")]
|
||||
use crate::spec::Target;
|
||||
|
||||
use std::convert::{TryFrom, TryInto};
|
||||
use std::fmt;
|
||||
#[cfg(feature = "nightly")]
|
||||
use std::iter::Step;
|
||||
use std::num::{NonZeroUsize, ParseIntError};
|
||||
use std::ops::{Add, AddAssign, Deref, Mul, RangeInclusive, Sub};
|
||||
use std::str::FromStr;
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
use rustc_data_structures::intern::Interned;
|
||||
use rustc_index::vec::{Idx, IndexVec};
|
||||
#[cfg(feature = "nightly")]
|
||||
use rustc_macros::HashStable_Generic;
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
pub mod call;
|
||||
|
||||
/// Parsed [Data layout](https://llvm.org/docs/LangRef.html#data-layout)
|
||||
/// for a target, which contains everything needed to compute layouts.
|
||||
#[derive(Debug, PartialEq, Eq)]
|
||||
pub struct TargetDataLayout {
|
||||
pub endian: Endian,
|
||||
pub i1_align: AbiAndPrefAlign,
|
||||
@ -80,6 +86,7 @@ pub enum TargetDataLayoutErrors<'a> {
|
||||
}
|
||||
|
||||
impl TargetDataLayout {
|
||||
#[cfg(feature = "nightly")]
|
||||
pub fn parse<'a>(target: &'a Target) -> Result<TargetDataLayout, TargetDataLayoutErrors<'a>> {
|
||||
// Parse an address space index from a string.
|
||||
let parse_address_space = |s: &'a str, cause: &'a str| {
|
||||
@ -248,7 +255,7 @@ impl HasDataLayout for TargetDataLayout {
|
||||
}
|
||||
|
||||
/// Endianness of the target, which must match cfg(target-endian).
|
||||
#[derive(Copy, Clone, PartialEq)]
|
||||
#[derive(Copy, Clone, PartialEq, Eq)]
|
||||
pub enum Endian {
|
||||
Little,
|
||||
Big,
|
||||
@ -288,8 +295,8 @@ impl ToJson for Endian {
|
||||
}
|
||||
|
||||
/// Size of a type in bytes.
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)]
|
||||
#[derive(HashStable_Generic)]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[cfg_attr(feature = "nightly", derive(Encodable, Decodable, HashStable_Generic))]
|
||||
pub struct Size {
|
||||
raw: u64,
|
||||
}
|
||||
@ -466,6 +473,7 @@ impl AddAssign for Size {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
impl Step for Size {
|
||||
#[inline]
|
||||
fn steps_between(start: &Self, end: &Self) -> Option<usize> {
|
||||
@ -504,8 +512,8 @@ impl Step for Size {
|
||||
}
|
||||
|
||||
/// Alignment of a type in bytes (always a power of two).
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)]
|
||||
#[derive(HashStable_Generic)]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
#[cfg_attr(feature = "nightly", derive(Encodable, Decodable, HashStable_Generic))]
|
||||
pub struct Align {
|
||||
pow2: u8,
|
||||
}
|
||||
@ -588,7 +596,8 @@ impl Align {
|
||||
|
||||
/// A pair of alignments, ABI-mandated and preferred.
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||
#[derive(HashStable_Generic)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
|
||||
pub struct AbiAndPrefAlign {
|
||||
pub abi: Align,
|
||||
pub pref: Align,
|
||||
@ -612,7 +621,9 @@ impl AbiAndPrefAlign {
|
||||
}
|
||||
|
||||
/// Integers, also used for enum discriminants.
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, HashStable_Generic)]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
|
||||
pub enum Integer {
|
||||
I8,
|
||||
I16,
|
||||
@ -710,7 +721,8 @@ impl Integer {
|
||||
}
|
||||
|
||||
/// Fundamental unit of memory access and layout.
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub enum Primitive {
|
||||
/// The `bool` is the signedness of the `Integer` type.
|
||||
///
|
||||
@ -777,7 +789,7 @@ impl Primitive {
|
||||
///
|
||||
/// This is intended specifically to mirror LLVM’s `!range` metadata semantics.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
||||
#[derive(HashStable_Generic)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub struct WrappingRange {
|
||||
pub start: u128,
|
||||
pub end: u128,
|
||||
@ -834,7 +846,7 @@ impl fmt::Debug for WrappingRange {
|
||||
|
||||
/// Information about one scalar component of a Rust type.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
|
||||
#[derive(HashStable_Generic)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub enum Scalar {
|
||||
Initialized {
|
||||
value: Primitive,
|
||||
@ -924,7 +936,8 @@ impl Scalar {
|
||||
}
|
||||
|
||||
/// Describes how the fields of a type are located in memory.
|
||||
#[derive(PartialEq, Eq, Hash, Debug, HashStable_Generic)]
|
||||
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub enum FieldsShape {
|
||||
/// Scalar primitives and `!`, which never have fields.
|
||||
Primitive,
|
||||
@ -1058,7 +1071,9 @@ impl AddressSpace {
|
||||
|
||||
/// Describes how values of the type are passed by target ABIs,
|
||||
/// in terms of categories of C types there are ABI rules for.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
|
||||
pub enum Abi {
|
||||
Uninhabited,
|
||||
Scalar(Scalar),
|
||||
@ -1113,16 +1128,18 @@ impl Abi {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
rustc_index::newtype_index! {
|
||||
pub struct VariantIdx {
|
||||
derive [HashStable_Generic]
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Hash, Debug, HashStable_Generic)]
|
||||
pub enum Variants<'a> {
|
||||
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub enum Variants<V: Idx> {
|
||||
/// Single enum variants, structs/tuples, unions, and all non-ADTs.
|
||||
Single { index: VariantIdx },
|
||||
Single { index: V },
|
||||
|
||||
/// Enum-likes with more than one inhabited variant: each variant comes with
|
||||
/// a *discriminant* (usually the same as the variant index but the user can
|
||||
@ -1132,14 +1149,15 @@ pub enum Variants<'a> {
|
||||
/// For enums, the tag is the sole field of the layout.
|
||||
Multiple {
|
||||
tag: Scalar,
|
||||
tag_encoding: TagEncoding,
|
||||
tag_encoding: TagEncoding<V>,
|
||||
tag_field: usize,
|
||||
variants: IndexVec<VariantIdx, Layout<'a>>,
|
||||
variants: IndexVec<V, LayoutS<V>>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Hash, Debug, HashStable_Generic)]
|
||||
pub enum TagEncoding {
|
||||
#[derive(PartialEq, Eq, Hash, Clone, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub enum TagEncoding<V: Idx> {
|
||||
/// The tag directly stores the discriminant, but possibly with a smaller layout
|
||||
/// (so converting the tag to the discriminant can require sign extension).
|
||||
Direct,
|
||||
@ -1155,13 +1173,15 @@ pub enum TagEncoding {
|
||||
/// `None` has a null pointer for the second tuple field, and
|
||||
/// `Some` is the identity function (with a non-null reference).
|
||||
Niche {
|
||||
untagged_variant: VariantIdx,
|
||||
niche_variants: RangeInclusive<VariantIdx>,
|
||||
untagged_variant: V,
|
||||
#[cfg(feature = "nightly")]
|
||||
niche_variants: RangeInclusive<V>,
|
||||
niche_start: u128,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub struct Niche {
|
||||
pub offset: Size,
|
||||
pub value: Primitive,
|
||||
@ -1244,8 +1264,9 @@ impl Niche {
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Eq, Hash, HashStable_Generic)]
|
||||
pub struct LayoutS<'a> {
|
||||
#[derive(PartialEq, Eq, Hash, Clone)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub struct LayoutS<V: Idx> {
|
||||
/// Says where the fields are located within the layout.
|
||||
pub fields: FieldsShape,
|
||||
|
||||
@ -1256,7 +1277,7 @@ pub struct LayoutS<'a> {
|
||||
///
|
||||
/// To access all fields of this layout, both `fields` and the fields of the active variant
|
||||
/// must be taken into account.
|
||||
pub variants: Variants<'a>,
|
||||
pub variants: Variants<V>,
|
||||
|
||||
/// The `abi` defines how this data is passed between functions, and it defines
|
||||
/// value restrictions via `valid_range`.
|
||||
@ -1275,13 +1296,13 @@ pub struct LayoutS<'a> {
|
||||
pub size: Size,
|
||||
}
|
||||
|
||||
impl<'a> LayoutS<'a> {
|
||||
impl<V: Idx> LayoutS<V> {
|
||||
pub fn scalar<C: HasDataLayout>(cx: &C, scalar: Scalar) -> Self {
|
||||
let largest_niche = Niche::from_scalar(cx, Size::ZERO, scalar);
|
||||
let size = scalar.size(cx);
|
||||
let align = scalar.align(cx);
|
||||
LayoutS {
|
||||
variants: Variants::Single { index: VariantIdx::new(0) },
|
||||
variants: Variants::Single { index: V::new(0) },
|
||||
fields: FieldsShape::Primitive,
|
||||
abi: Abi::Scalar(scalar),
|
||||
largest_niche,
|
||||
@ -1289,9 +1310,39 @@ impl<'a> LayoutS<'a> {
|
||||
align,
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn fields(&self) -> &FieldsShape {
|
||||
&self.fields
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn variants(&self) -> &Variants<V> {
|
||||
&self.variants
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn abi(&self) -> Abi {
|
||||
self.abi
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn largest_niche(&self) -> Option<Niche> {
|
||||
self.largest_niche
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn align(&self) -> AbiAndPrefAlign {
|
||||
self.align
|
||||
}
|
||||
|
||||
#[inline]
|
||||
pub fn size(&self) -> Size {
|
||||
self.size
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> fmt::Debug for LayoutS<'a> {
|
||||
impl<V: Idx> fmt::Debug for LayoutS<V> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
// This is how `Layout` used to print before it become
|
||||
// `Interned<LayoutS>`. We print it like this to avoid having to update
|
||||
@ -1308,10 +1359,12 @@ impl<'a> fmt::Debug for LayoutS<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]
|
||||
#[rustc_pass_by_value]
|
||||
pub struct Layout<'a>(pub Interned<'a, LayoutS<'a>>);
|
||||
pub struct Layout<'a>(pub Interned<'a, LayoutS<VariantIdx>>);
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
impl<'a> fmt::Debug for Layout<'a> {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
// See comment on `<LayoutS as Debug>::fmt` above.
|
||||
@ -1319,12 +1372,13 @@ impl<'a> fmt::Debug for Layout<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
impl<'a> Layout<'a> {
|
||||
pub fn fields(self) -> &'a FieldsShape {
|
||||
&self.0.0.fields
|
||||
}
|
||||
|
||||
pub fn variants(self) -> &'a Variants<'a> {
|
||||
pub fn variants(self) -> &'a Variants<VariantIdx> {
|
||||
&self.0.0.variants
|
||||
}
|
||||
|
||||
@ -1352,15 +1406,18 @@ impl<'a> Layout<'a> {
|
||||
/// to that obtained from `layout_of(ty)`, as we need to produce
|
||||
/// layouts for which Rust types do not exist, such as enum variants
|
||||
/// or synthetic fields of enums (i.e., discriminants) and fat pointers.
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable_Generic)]
|
||||
#[cfg(feature = "nightly")]
|
||||
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
|
||||
#[cfg_attr(feature = "nightly", derive(HashStable_Generic))]
|
||||
pub struct TyAndLayout<'a, Ty> {
|
||||
pub ty: Ty,
|
||||
pub layout: Layout<'a>,
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
impl<'a, Ty> Deref for TyAndLayout<'a, Ty> {
|
||||
type Target = &'a LayoutS<'a>;
|
||||
fn deref(&self) -> &&'a LayoutS<'a> {
|
||||
type Target = &'a LayoutS<VariantIdx>;
|
||||
fn deref(&self) -> &&'a LayoutS<VariantIdx> {
|
||||
&self.layout.0.0
|
||||
}
|
||||
}
|
||||
@ -1402,6 +1459,7 @@ pub enum InitKind {
|
||||
|
||||
/// Trait that needs to be implemented by the higher-level type representation
|
||||
/// (e.g. `rustc_middle::ty::Ty`), to provide `rustc_target::abi` functionality.
|
||||
#[cfg(feature = "nightly")]
|
||||
pub trait TyAbiInterface<'a, C>: Sized {
|
||||
fn ty_and_layout_for_variant(
|
||||
this: TyAndLayout<'a, Self>,
|
||||
@ -1420,6 +1478,7 @@ pub trait TyAbiInterface<'a, C>: Sized {
|
||||
fn is_unit(this: TyAndLayout<'a, Self>) -> bool;
|
||||
}
|
||||
|
||||
#[cfg(feature = "nightly")]
|
||||
impl<'a, Ty> TyAndLayout<'a, Ty> {
|
||||
pub fn for_variant<C>(self, cx: &C, variant_index: VariantIdx) -> Self
|
||||
where
|
||||
@ -1489,7 +1548,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, Ty> TyAndLayout<'a, Ty> {
|
||||
impl<V: Idx> LayoutS<V> {
|
||||
/// Returns `true` if the layout corresponds to an unsized type.
|
||||
pub fn is_unsized(&self) -> bool {
|
||||
self.abi.is_unsized()
|
||||
|
@ -8,13 +8,13 @@
|
||||
//! LLVM.
|
||||
|
||||
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
|
||||
#![feature(assert_matches)]
|
||||
#![feature(associated_type_bounds)]
|
||||
#![feature(exhaustive_patterns)]
|
||||
#![feature(min_specialization)]
|
||||
#![feature(never_type)]
|
||||
#![feature(rustc_attrs)]
|
||||
#![feature(step_trait)]
|
||||
#![cfg_attr(feature = "nightly", feature(assert_matches))]
|
||||
#![cfg_attr(feature = "nightly", feature(associated_type_bounds))]
|
||||
#![cfg_attr(feature = "nightly", feature(exhaustive_patterns))]
|
||||
#![cfg_attr(feature = "nightly", feature(min_specialization))]
|
||||
#![cfg_attr(feature = "nightly", feature(never_type))]
|
||||
#![cfg_attr(feature = "nightly", feature(rustc_attrs))]
|
||||
#![cfg_attr(feature = "nightly", feature(step_trait))]
|
||||
#![deny(rustc::untranslatable_diagnostic)]
|
||||
#![deny(rustc::diagnostic_outside_of_impl)]
|
||||
|
||||
@ -22,14 +22,18 @@ use std::iter::FromIterator;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[macro_use]
|
||||
#[cfg(feature = "nightly")]
|
||||
extern crate rustc_macros;
|
||||
|
||||
#[macro_use]
|
||||
#[cfg(feature = "nightly")]
|
||||
extern crate tracing;
|
||||
|
||||
pub mod abi;
|
||||
#[cfg(feature = "nightly")]
|
||||
pub mod asm;
|
||||
pub mod json;
|
||||
#[cfg(feature = "nightly")]
|
||||
pub mod spec;
|
||||
|
||||
#[cfg(test)]
|
||||
|
@ -89,7 +89,11 @@ fn invert_mapping(map: &[u32]) -> Vec<u32> {
|
||||
inverse
|
||||
}
|
||||
|
||||
fn scalar_pair<'tcx>(cx: &LayoutCx<'tcx, TyCtxt<'tcx>>, a: Scalar, b: Scalar) -> LayoutS<'tcx> {
|
||||
fn scalar_pair<'tcx>(
|
||||
cx: &LayoutCx<'tcx, TyCtxt<'tcx>>,
|
||||
a: Scalar,
|
||||
b: Scalar,
|
||||
) -> LayoutS<VariantIdx> {
|
||||
let dl = cx.data_layout();
|
||||
let b_align = b.align(dl);
|
||||
let align = a.align(dl).max(b_align).max(dl.aggregate_align);
|
||||
@ -122,7 +126,7 @@ fn univariant_uninterned<'tcx>(
|
||||
fields: &[TyAndLayout<'_>],
|
||||
repr: &ReprOptions,
|
||||
kind: StructKind,
|
||||
) -> Result<LayoutS<'tcx>, LayoutError<'tcx>> {
|
||||
) -> Result<LayoutS<VariantIdx>, LayoutError<'tcx>> {
|
||||
let dl = cx.data_layout();
|
||||
let pack = repr.pack;
|
||||
if pack.is_some() && repr.align.is_some() {
|
||||
@ -864,13 +868,13 @@ fn layout_of_uncached<'tcx>(
|
||||
// variant layouts, so we can't store them in the
|
||||
// overall LayoutS. Store the overall LayoutS
|
||||
// and the variant LayoutSs here until then.
|
||||
struct TmpLayout<'tcx> {
|
||||
layout: LayoutS<'tcx>,
|
||||
variants: IndexVec<VariantIdx, LayoutS<'tcx>>,
|
||||
struct TmpLayout {
|
||||
layout: LayoutS<VariantIdx>,
|
||||
variants: IndexVec<VariantIdx, LayoutS<VariantIdx>>,
|
||||
}
|
||||
|
||||
let calculate_niche_filling_layout =
|
||||
|| -> Result<Option<TmpLayout<'tcx>>, LayoutError<'tcx>> {
|
||||
|| -> Result<Option<TmpLayout>, LayoutError<'tcx>> {
|
||||
// The current code for niche-filling relies on variant indices
|
||||
// instead of actual discriminants, so enums with
|
||||
// explicit discriminants (RFC #2363) would misbehave.
|
||||
@ -1317,7 +1321,7 @@ fn layout_of_uncached<'tcx>(
|
||||
// pick the layout with the larger niche; otherwise,
|
||||
// pick tagged as it has simpler codegen.
|
||||
use Ordering::*;
|
||||
let niche_size = |tmp_l: &TmpLayout<'_>| {
|
||||
let niche_size = |tmp_l: &TmpLayout| {
|
||||
tmp_l.layout.largest_niche.map_or(0, |n| n.available(dl))
|
||||
};
|
||||
match (
|
||||
@ -1338,11 +1342,7 @@ fn layout_of_uncached<'tcx>(
|
||||
tag,
|
||||
tag_encoding,
|
||||
tag_field,
|
||||
variants: best_layout
|
||||
.variants
|
||||
.into_iter()
|
||||
.map(|layout| tcx.intern_layout(layout))
|
||||
.collect(),
|
||||
variants: best_layout.variants,
|
||||
},
|
||||
_ => bug!(),
|
||||
};
|
||||
@ -1657,7 +1657,7 @@ fn generator_layout<'tcx>(
|
||||
|
||||
size = size.max(variant.size);
|
||||
align = align.max(variant.align);
|
||||
Ok(tcx.intern_layout(variant))
|
||||
Ok(variant)
|
||||
})
|
||||
.collect::<Result<IndexVec<VariantIdx, _>, _>>()?;
|
||||
|
||||
|
@ -10,7 +10,7 @@ use rustc_middle::ty::layout::LayoutError;
|
||||
use rustc_middle::ty::{self, Adt, TyCtxt};
|
||||
use rustc_span::hygiene::MacroKind;
|
||||
use rustc_span::symbol::{kw, sym, Symbol};
|
||||
use rustc_target::abi::{Layout, Primitive, TagEncoding, Variants};
|
||||
use rustc_target::abi::{LayoutS, Primitive, TagEncoding, VariantIdx, Variants};
|
||||
use std::cmp::Ordering;
|
||||
use std::fmt;
|
||||
use std::rc::Rc;
|
||||
@ -1892,7 +1892,7 @@ fn document_non_exhaustive(w: &mut Buffer, item: &clean::Item) {
|
||||
}
|
||||
|
||||
fn document_type_layout(w: &mut Buffer, cx: &Context<'_>, ty_def_id: DefId) {
|
||||
fn write_size_of_layout(w: &mut Buffer, layout: Layout<'_>, tag_size: u64) {
|
||||
fn write_size_of_layout(w: &mut Buffer, layout: &LayoutS<VariantIdx>, tag_size: u64) {
|
||||
if layout.abi().is_unsized() {
|
||||
write!(w, "(unsized)");
|
||||
} else {
|
||||
@ -1927,7 +1927,7 @@ fn document_type_layout(w: &mut Buffer, cx: &Context<'_>, ty_def_id: DefId) {
|
||||
chapter for details on type layout guarantees.</p></div>"
|
||||
);
|
||||
w.write_str("<p><strong>Size:</strong> ");
|
||||
write_size_of_layout(w, ty_layout.layout, 0);
|
||||
write_size_of_layout(w, &ty_layout.layout.0, 0);
|
||||
writeln!(w, "</p>");
|
||||
if let Variants::Multiple { variants, tag, tag_encoding, .. } =
|
||||
&ty_layout.layout.variants()
|
||||
@ -1953,7 +1953,7 @@ fn document_type_layout(w: &mut Buffer, cx: &Context<'_>, ty_def_id: DefId) {
|
||||
for (index, layout) in variants.iter_enumerated() {
|
||||
let name = adt.variant(index).name;
|
||||
write!(w, "<li><code>{name}</code>: ", name = name);
|
||||
write_size_of_layout(w, *layout, tag_size);
|
||||
write_size_of_layout(w, layout, tag_size);
|
||||
writeln!(w, "</li>");
|
||||
}
|
||||
w.write_str("</ul>");
|
||||
|
Loading…
Reference in New Issue
Block a user