Auto merge of #140079 - ChrisDenton:rollup-2h5cg94, r=ChrisDenton
Rollup of 5 pull requests Successful merges: - #137953 (simd intrinsics with mask: accept unsigned integer masks, and fix some of the errors) - #139990 (transmutability: remove NFA intermediate representation) - #140044 (rustc-dev-guide subtree update) - #140051 (Switch exploit mitigations to mdbook footnotes) - #140054 (docs: fix typo change from inconstants to invariants) r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
b8005bff32
60 changed files with 895 additions and 595 deletions
|
|
@ -447,9 +447,14 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
|
|||
m_len == v_len,
|
||||
InvalidMonomorphization::MismatchedLengths { span, name, m_len, v_len }
|
||||
);
|
||||
// TODO: also support unsigned integers.
|
||||
match *m_elem_ty.kind() {
|
||||
ty::Int(_) => {}
|
||||
_ => return_error!(InvalidMonomorphization::MaskType { span, name, ty: m_elem_ty }),
|
||||
_ => return_error!(InvalidMonomorphization::MaskWrongElementType {
|
||||
span,
|
||||
name,
|
||||
ty: m_elem_ty
|
||||
}),
|
||||
}
|
||||
return Ok(bx.vector_select(args[0].immediate(), args[1].immediate(), args[2].immediate()));
|
||||
}
|
||||
|
|
@ -991,19 +996,15 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
|
|||
assert_eq!(pointer_count - 1, ptr_count(element_ty0));
|
||||
assert_eq!(underlying_ty, non_ptr(element_ty0));
|
||||
|
||||
// The element type of the third argument must be a signed integer type of any width:
|
||||
// The element type of the third argument must be an integer type of any width:
|
||||
// TODO: also support unsigned integers.
|
||||
let (_, element_ty2) = arg_tys[2].simd_size_and_type(bx.tcx());
|
||||
match *element_ty2.kind() {
|
||||
ty::Int(_) => (),
|
||||
_ => {
|
||||
require!(
|
||||
false,
|
||||
InvalidMonomorphization::ThirdArgElementType {
|
||||
span,
|
||||
name,
|
||||
expected_element: element_ty2,
|
||||
third_arg: arg_tys[2]
|
||||
}
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: element_ty2 }
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
@ -1109,17 +1110,13 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
|
|||
assert_eq!(underlying_ty, non_ptr(element_ty0));
|
||||
|
||||
// The element type of the third argument must be a signed integer type of any width:
|
||||
// TODO: also support unsigned integers.
|
||||
match *element_ty2.kind() {
|
||||
ty::Int(_) => (),
|
||||
_ => {
|
||||
require!(
|
||||
false,
|
||||
InvalidMonomorphization::ThirdArgElementType {
|
||||
span,
|
||||
name,
|
||||
expected_element: element_ty2,
|
||||
third_arg: arg_tys[2]
|
||||
}
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: element_ty2 }
|
||||
);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1184,18 +1184,6 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
}};
|
||||
}
|
||||
|
||||
/// Returns the bitwidth of the `$ty` argument if it is an `Int` type.
|
||||
macro_rules! require_int_ty {
|
||||
($ty: expr, $diag: expr) => {
|
||||
match $ty {
|
||||
ty::Int(i) => i.bit_width().unwrap_or_else(|| bx.data_layout().pointer_size.bits()),
|
||||
_ => {
|
||||
return_error!($diag);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
/// Returns the bitwidth of the `$ty` argument if it is an `Int` or `Uint` type.
|
||||
macro_rules! require_int_or_uint_ty {
|
||||
($ty: expr, $diag: expr) => {
|
||||
|
|
@ -1485,9 +1473,9 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
m_len == v_len,
|
||||
InvalidMonomorphization::MismatchedLengths { span, name, m_len, v_len }
|
||||
);
|
||||
let in_elem_bitwidth = require_int_ty!(
|
||||
let in_elem_bitwidth = require_int_or_uint_ty!(
|
||||
m_elem_ty.kind(),
|
||||
InvalidMonomorphization::MaskType { span, name, ty: m_elem_ty }
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: m_elem_ty }
|
||||
);
|
||||
let m_i1s = vector_mask_to_bitmask(bx, args[0].immediate(), in_elem_bitwidth, m_len);
|
||||
return Ok(bx.select(m_i1s, args[1].immediate(), args[2].immediate()));
|
||||
|
|
@ -1508,7 +1496,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
// Integer vector <i{in_bitwidth} x in_len>:
|
||||
let in_elem_bitwidth = require_int_or_uint_ty!(
|
||||
in_elem.kind(),
|
||||
InvalidMonomorphization::VectorArgument { span, name, in_ty, in_elem }
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: in_elem }
|
||||
);
|
||||
|
||||
let i1xn = vector_mask_to_bitmask(bx, args[0].immediate(), in_elem_bitwidth, in_len);
|
||||
|
|
@ -1732,14 +1720,9 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
}
|
||||
);
|
||||
|
||||
let mask_elem_bitwidth = require_int_ty!(
|
||||
let mask_elem_bitwidth = require_int_or_uint_ty!(
|
||||
element_ty2.kind(),
|
||||
InvalidMonomorphization::ThirdArgElementType {
|
||||
span,
|
||||
name,
|
||||
expected_element: element_ty2,
|
||||
third_arg: arg_tys[2]
|
||||
}
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: element_ty2 }
|
||||
);
|
||||
|
||||
// Alignment of T, must be a constant integer value:
|
||||
|
|
@ -1834,14 +1817,9 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
}
|
||||
);
|
||||
|
||||
let m_elem_bitwidth = require_int_ty!(
|
||||
let m_elem_bitwidth = require_int_or_uint_ty!(
|
||||
mask_elem.kind(),
|
||||
InvalidMonomorphization::ThirdArgElementType {
|
||||
span,
|
||||
name,
|
||||
expected_element: values_elem,
|
||||
third_arg: mask_ty,
|
||||
}
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: mask_elem }
|
||||
);
|
||||
|
||||
let mask = vector_mask_to_bitmask(bx, args[0].immediate(), m_elem_bitwidth, mask_len);
|
||||
|
|
@ -1924,14 +1902,9 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
}
|
||||
);
|
||||
|
||||
let m_elem_bitwidth = require_int_ty!(
|
||||
let m_elem_bitwidth = require_int_or_uint_ty!(
|
||||
mask_elem.kind(),
|
||||
InvalidMonomorphization::ThirdArgElementType {
|
||||
span,
|
||||
name,
|
||||
expected_element: values_elem,
|
||||
third_arg: mask_ty,
|
||||
}
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: mask_elem }
|
||||
);
|
||||
|
||||
let mask = vector_mask_to_bitmask(bx, args[0].immediate(), m_elem_bitwidth, mask_len);
|
||||
|
|
@ -2019,15 +1992,10 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
|
|||
}
|
||||
);
|
||||
|
||||
// The element type of the third argument must be a signed integer type of any width:
|
||||
let mask_elem_bitwidth = require_int_ty!(
|
||||
// The element type of the third argument must be an integer type of any width:
|
||||
let mask_elem_bitwidth = require_int_or_uint_ty!(
|
||||
element_ty2.kind(),
|
||||
InvalidMonomorphization::ThirdArgElementType {
|
||||
span,
|
||||
name,
|
||||
expected_element: element_ty2,
|
||||
third_arg: arg_tys[2]
|
||||
}
|
||||
InvalidMonomorphization::MaskWrongElementType { span, name, ty: element_ty2 }
|
||||
);
|
||||
|
||||
// Alignment of T, must be a constant integer value:
|
||||
|
|
|
|||
|
|
@ -125,8 +125,7 @@ codegen_ssa_invalid_monomorphization_inserted_type = invalid monomorphization of
|
|||
|
||||
codegen_ssa_invalid_monomorphization_invalid_bitmask = invalid monomorphization of `{$name}` intrinsic: invalid bitmask `{$mask_ty}`, expected `u{$expected_int_bits}` or `[u8; {$expected_bytes}]`
|
||||
|
||||
codegen_ssa_invalid_monomorphization_mask_type = invalid monomorphization of `{$name}` intrinsic: found mask element type is `{$ty}`, expected a signed integer type
|
||||
.note = the mask may be widened, which only has the correct behavior for signed integers
|
||||
codegen_ssa_invalid_monomorphization_mask_wrong_element_type = invalid monomorphization of `{$name}` intrinsic: expected mask element type to be an integer, found `{$ty}`
|
||||
|
||||
codegen_ssa_invalid_monomorphization_mismatched_lengths = invalid monomorphization of `{$name}` intrinsic: mismatched lengths: mask length `{$m_len}` != other vector length `{$v_len}`
|
||||
|
||||
|
|
@ -158,8 +157,6 @@ codegen_ssa_invalid_monomorphization_simd_shuffle = invalid monomorphization of
|
|||
|
||||
codegen_ssa_invalid_monomorphization_simd_third = invalid monomorphization of `{$name}` intrinsic: expected SIMD third type, found non-SIMD `{$ty}`
|
||||
|
||||
codegen_ssa_invalid_monomorphization_third_arg_element_type = invalid monomorphization of `{$name}` intrinsic: expected element type `{$expected_element}` of third argument `{$third_arg}` to be a signed integer type
|
||||
|
||||
codegen_ssa_invalid_monomorphization_third_argument_length = invalid monomorphization of `{$name}` intrinsic: expected third argument with length {$in_len} (same as input type `{$in_ty}`), found `{$arg_ty}` with length {$out_len}
|
||||
|
||||
codegen_ssa_invalid_monomorphization_unrecognized_intrinsic = invalid monomorphization of `{$name}` intrinsic: unrecognized intrinsic `{$name}`
|
||||
|
|
@ -172,8 +169,6 @@ codegen_ssa_invalid_monomorphization_unsupported_symbol = invalid monomorphizati
|
|||
|
||||
codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size = invalid monomorphization of `{$name}` intrinsic: unsupported {$symbol} from `{$in_ty}` with element `{$in_elem}` of size `{$size}` to `{$ret_ty}`
|
||||
|
||||
codegen_ssa_invalid_monomorphization_vector_argument = invalid monomorphization of `{$name}` intrinsic: vector argument `{$in_ty}`'s element type `{$in_elem}`, expected integer element type
|
||||
|
||||
codegen_ssa_invalid_no_sanitize = invalid argument for `no_sanitize`
|
||||
.note = expected one of: `address`, `cfi`, `hwaddress`, `kcfi`, `memory`, `memtag`, `shadow-call-stack`, or `thread`
|
||||
|
||||
|
|
|
|||
|
|
@ -1037,24 +1037,14 @@ pub enum InvalidMonomorphization<'tcx> {
|
|||
v_len: u64,
|
||||
},
|
||||
|
||||
#[diag(codegen_ssa_invalid_monomorphization_mask_type, code = E0511)]
|
||||
#[note]
|
||||
MaskType {
|
||||
#[diag(codegen_ssa_invalid_monomorphization_mask_wrong_element_type, code = E0511)]
|
||||
MaskWrongElementType {
|
||||
#[primary_span]
|
||||
span: Span,
|
||||
name: Symbol,
|
||||
ty: Ty<'tcx>,
|
||||
},
|
||||
|
||||
#[diag(codegen_ssa_invalid_monomorphization_vector_argument, code = E0511)]
|
||||
VectorArgument {
|
||||
#[primary_span]
|
||||
span: Span,
|
||||
name: Symbol,
|
||||
in_ty: Ty<'tcx>,
|
||||
in_elem: Ty<'tcx>,
|
||||
},
|
||||
|
||||
#[diag(codegen_ssa_invalid_monomorphization_cannot_return, code = E0511)]
|
||||
CannotReturn {
|
||||
#[primary_span]
|
||||
|
|
@ -1077,15 +1067,6 @@ pub enum InvalidMonomorphization<'tcx> {
|
|||
mutability: ExpectedPointerMutability,
|
||||
},
|
||||
|
||||
#[diag(codegen_ssa_invalid_monomorphization_third_arg_element_type, code = E0511)]
|
||||
ThirdArgElementType {
|
||||
#[primary_span]
|
||||
span: Span,
|
||||
name: Symbol,
|
||||
expected_element: Ty<'tcx>,
|
||||
third_arg: Ty<'tcx>,
|
||||
},
|
||||
|
||||
#[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size, code = E0511)]
|
||||
UnsupportedSymbolOfSize {
|
||||
#[primary_span]
|
||||
|
|
|
|||
|
|
@ -1,19 +1,18 @@
|
|||
use std::fmt;
|
||||
use std::sync::atomic::{AtomicU32, Ordering};
|
||||
|
||||
use tracing::instrument;
|
||||
|
||||
use super::{Byte, Nfa, Ref, nfa};
|
||||
use super::{Byte, Ref, Tree, Uninhabited};
|
||||
use crate::Map;
|
||||
|
||||
#[derive(PartialEq, Clone, Debug)]
|
||||
#[derive(PartialEq)]
|
||||
#[cfg_attr(test, derive(Clone))]
|
||||
pub(crate) struct Dfa<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
pub(crate) transitions: Map<State, Transitions<R>>,
|
||||
pub(crate) start: State,
|
||||
pub(crate) accepting: State,
|
||||
pub(crate) accept: State,
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Clone, Debug)]
|
||||
|
|
@ -34,35 +33,15 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<R> Transitions<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
#[cfg(test)]
|
||||
fn insert(&mut self, transition: Transition<R>, state: State) {
|
||||
match transition {
|
||||
Transition::Byte(b) => {
|
||||
self.byte_transitions.insert(b, state);
|
||||
}
|
||||
Transition::Ref(r) => {
|
||||
self.ref_transitions.insert(r, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The states in a `Nfa` represent byte offsets.
|
||||
/// The states in a [`Dfa`] represent byte offsets.
|
||||
#[derive(Hash, Eq, PartialEq, PartialOrd, Ord, Copy, Clone)]
|
||||
pub(crate) struct State(u32);
|
||||
pub(crate) struct State(pub(crate) u32);
|
||||
|
||||
#[cfg(test)]
|
||||
#[derive(Hash, Eq, PartialEq, Clone, Copy)]
|
||||
pub(crate) enum Transition<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
Byte(Byte),
|
||||
Ref(R),
|
||||
impl State {
|
||||
pub(crate) fn new() -> Self {
|
||||
static COUNTER: AtomicU32 = AtomicU32::new(0);
|
||||
Self(COUNTER.fetch_add(1, Ordering::SeqCst))
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Debug for State {
|
||||
|
|
@ -71,19 +50,6 @@ impl fmt::Debug for State {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl<R> fmt::Debug for Transition<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match &self {
|
||||
Self::Byte(b) => b.fmt(f),
|
||||
Self::Ref(r) => r.fmt(f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> Dfa<R>
|
||||
where
|
||||
R: Ref,
|
||||
|
|
@ -92,60 +58,167 @@ where
|
|||
pub(crate) fn bool() -> Self {
|
||||
let mut transitions: Map<State, Transitions<R>> = Map::default();
|
||||
let start = State::new();
|
||||
let accepting = State::new();
|
||||
let accept = State::new();
|
||||
|
||||
transitions.entry(start).or_default().insert(Transition::Byte(Byte::Init(0x00)), accepting);
|
||||
transitions.entry(start).or_default().byte_transitions.insert(Byte::Init(0x00), accept);
|
||||
|
||||
transitions.entry(start).or_default().insert(Transition::Byte(Byte::Init(0x01)), accepting);
|
||||
transitions.entry(start).or_default().byte_transitions.insert(Byte::Init(0x01), accept);
|
||||
|
||||
Self { transitions, start, accepting }
|
||||
Self { transitions, start, accept }
|
||||
}
|
||||
|
||||
#[instrument(level = "debug")]
|
||||
pub(crate) fn from_nfa(nfa: Nfa<R>) -> Self {
|
||||
let Nfa { transitions: nfa_transitions, start: nfa_start, accepting: nfa_accepting } = nfa;
|
||||
pub(crate) fn unit() -> Self {
|
||||
let transitions: Map<State, Transitions<R>> = Map::default();
|
||||
let start = State::new();
|
||||
let accept = start;
|
||||
|
||||
let mut dfa_transitions: Map<State, Transitions<R>> = Map::default();
|
||||
let mut nfa_to_dfa: Map<nfa::State, State> = Map::default();
|
||||
let dfa_start = State::new();
|
||||
nfa_to_dfa.insert(nfa_start, dfa_start);
|
||||
Self { transitions, start, accept }
|
||||
}
|
||||
|
||||
let mut queue = vec![(nfa_start, dfa_start)];
|
||||
pub(crate) fn from_byte(byte: Byte) -> Self {
|
||||
let mut transitions: Map<State, Transitions<R>> = Map::default();
|
||||
let start = State::new();
|
||||
let accept = State::new();
|
||||
|
||||
while let Some((nfa_state, dfa_state)) = queue.pop() {
|
||||
if nfa_state == nfa_accepting {
|
||||
continue;
|
||||
transitions.entry(start).or_default().byte_transitions.insert(byte, accept);
|
||||
|
||||
Self { transitions, start, accept }
|
||||
}
|
||||
|
||||
pub(crate) fn from_ref(r: R) -> Self {
|
||||
let mut transitions: Map<State, Transitions<R>> = Map::default();
|
||||
let start = State::new();
|
||||
let accept = State::new();
|
||||
|
||||
transitions.entry(start).or_default().ref_transitions.insert(r, accept);
|
||||
|
||||
Self { transitions, start, accept }
|
||||
}
|
||||
|
||||
pub(crate) fn from_tree(tree: Tree<!, R>) -> Result<Self, Uninhabited> {
|
||||
Ok(match tree {
|
||||
Tree::Byte(b) => Self::from_byte(b),
|
||||
Tree::Ref(r) => Self::from_ref(r),
|
||||
Tree::Alt(alts) => {
|
||||
// Convert and filter the inhabited alternatives.
|
||||
let mut alts = alts.into_iter().map(Self::from_tree).filter_map(Result::ok);
|
||||
// If there are no alternatives, return `Uninhabited`.
|
||||
let dfa = alts.next().ok_or(Uninhabited)?;
|
||||
// Combine the remaining alternatives with `dfa`.
|
||||
alts.fold(dfa, |dfa, alt| dfa.union(alt, State::new))
|
||||
}
|
||||
Tree::Seq(elts) => {
|
||||
let mut dfa = Self::unit();
|
||||
for elt in elts.into_iter().map(Self::from_tree) {
|
||||
dfa = dfa.concat(elt?);
|
||||
}
|
||||
dfa
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Concatenate two `Dfa`s.
|
||||
pub(crate) fn concat(self, other: Self) -> Self {
|
||||
if self.start == self.accept {
|
||||
return other;
|
||||
} else if other.start == other.accept {
|
||||
return self;
|
||||
}
|
||||
|
||||
let start = self.start;
|
||||
let accept = other.accept;
|
||||
|
||||
let mut transitions: Map<State, Transitions<R>> = self.transitions;
|
||||
|
||||
for (source, transition) in other.transitions {
|
||||
let fix_state = |state| if state == other.start { self.accept } else { state };
|
||||
let entry = transitions.entry(fix_state(source)).or_default();
|
||||
for (edge, destination) in transition.byte_transitions {
|
||||
entry.byte_transitions.insert(edge, fix_state(destination));
|
||||
}
|
||||
for (edge, destination) in transition.ref_transitions {
|
||||
entry.ref_transitions.insert(edge, fix_state(destination));
|
||||
}
|
||||
}
|
||||
|
||||
Self { transitions, start, accept }
|
||||
}
|
||||
|
||||
/// Compute the union of two `Dfa`s.
|
||||
pub(crate) fn union(self, other: Self, mut new_state: impl FnMut() -> State) -> Self {
|
||||
// We implement `union` by lazily initializing a set of states
|
||||
// corresponding to the product of states in `self` and `other`, and
|
||||
// then add transitions between these states that correspond to where
|
||||
// they exist between `self` and `other`.
|
||||
|
||||
let a = self;
|
||||
let b = other;
|
||||
|
||||
let accept = new_state();
|
||||
|
||||
let mut mapping: Map<(Option<State>, Option<State>), State> = Map::default();
|
||||
|
||||
let mut mapped = |(a_state, b_state)| {
|
||||
if Some(a.accept) == a_state || Some(b.accept) == b_state {
|
||||
// If either `a_state` or `b_state` are accepting, map to a
|
||||
// common `accept` state.
|
||||
accept
|
||||
} else {
|
||||
*mapping.entry((a_state, b_state)).or_insert_with(&mut new_state)
|
||||
}
|
||||
};
|
||||
|
||||
let start = mapped((Some(a.start), Some(b.start)));
|
||||
let mut transitions: Map<State, Transitions<R>> = Map::default();
|
||||
let mut queue = vec![(Some(a.start), Some(b.start))];
|
||||
let empty_transitions = Transitions::default();
|
||||
|
||||
while let Some((a_src, b_src)) = queue.pop() {
|
||||
let a_transitions =
|
||||
a_src.and_then(|a_src| a.transitions.get(&a_src)).unwrap_or(&empty_transitions);
|
||||
let b_transitions =
|
||||
b_src.and_then(|b_src| b.transitions.get(&b_src)).unwrap_or(&empty_transitions);
|
||||
|
||||
let byte_transitions =
|
||||
a_transitions.byte_transitions.keys().chain(b_transitions.byte_transitions.keys());
|
||||
|
||||
for byte_transition in byte_transitions {
|
||||
let a_dst = a_transitions.byte_transitions.get(byte_transition).copied();
|
||||
let b_dst = b_transitions.byte_transitions.get(byte_transition).copied();
|
||||
|
||||
assert!(a_dst.is_some() || b_dst.is_some());
|
||||
|
||||
let src = mapped((a_src, b_src));
|
||||
let dst = mapped((a_dst, b_dst));
|
||||
|
||||
transitions.entry(src).or_default().byte_transitions.insert(*byte_transition, dst);
|
||||
|
||||
if !transitions.contains_key(&dst) {
|
||||
queue.push((a_dst, b_dst))
|
||||
}
|
||||
}
|
||||
|
||||
for (nfa_transition, next_nfa_states) in nfa_transitions[&nfa_state].iter() {
|
||||
let dfa_transitions =
|
||||
dfa_transitions.entry(dfa_state).or_insert_with(Default::default);
|
||||
let ref_transitions =
|
||||
a_transitions.ref_transitions.keys().chain(b_transitions.ref_transitions.keys());
|
||||
|
||||
let mapped_state = next_nfa_states.iter().find_map(|x| nfa_to_dfa.get(x).copied());
|
||||
for ref_transition in ref_transitions {
|
||||
let a_dst = a_transitions.ref_transitions.get(ref_transition).copied();
|
||||
let b_dst = b_transitions.ref_transitions.get(ref_transition).copied();
|
||||
|
||||
let next_dfa_state = match nfa_transition {
|
||||
&nfa::Transition::Byte(b) => *dfa_transitions
|
||||
.byte_transitions
|
||||
.entry(b)
|
||||
.or_insert_with(|| mapped_state.unwrap_or_else(State::new)),
|
||||
&nfa::Transition::Ref(r) => *dfa_transitions
|
||||
.ref_transitions
|
||||
.entry(r)
|
||||
.or_insert_with(|| mapped_state.unwrap_or_else(State::new)),
|
||||
};
|
||||
assert!(a_dst.is_some() || b_dst.is_some());
|
||||
|
||||
for &next_nfa_state in next_nfa_states {
|
||||
nfa_to_dfa.entry(next_nfa_state).or_insert_with(|| {
|
||||
queue.push((next_nfa_state, next_dfa_state));
|
||||
next_dfa_state
|
||||
});
|
||||
let src = mapped((a_src, b_src));
|
||||
let dst = mapped((a_dst, b_dst));
|
||||
|
||||
transitions.entry(src).or_default().ref_transitions.insert(*ref_transition, dst);
|
||||
|
||||
if !transitions.contains_key(&dst) {
|
||||
queue.push((a_dst, b_dst))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let dfa_accepting = nfa_to_dfa[&nfa_accepting];
|
||||
|
||||
Self { transitions: dfa_transitions, start: dfa_start, accepting: dfa_accepting }
|
||||
Self { transitions, start, accept }
|
||||
}
|
||||
|
||||
pub(crate) fn bytes_from(&self, start: State) -> Option<&Map<Byte, State>> {
|
||||
|
|
@ -159,24 +232,48 @@ where
|
|||
pub(crate) fn refs_from(&self, start: State) -> Option<&Map<R, State>> {
|
||||
Some(&self.transitions.get(&start)?.ref_transitions)
|
||||
}
|
||||
}
|
||||
|
||||
impl State {
|
||||
pub(crate) fn new() -> Self {
|
||||
static COUNTER: AtomicU32 = AtomicU32::new(0);
|
||||
Self(COUNTER.fetch_add(1, Ordering::SeqCst))
|
||||
#[cfg(test)]
|
||||
pub(crate) fn from_edges<B: Copy + Into<Byte>>(
|
||||
start: u32,
|
||||
accept: u32,
|
||||
edges: &[(u32, B, u32)],
|
||||
) -> Self {
|
||||
let start = State(start);
|
||||
let accept = State(accept);
|
||||
let mut transitions: Map<State, Transitions<R>> = Map::default();
|
||||
|
||||
for &(src, edge, dst) in edges {
|
||||
let src = State(src);
|
||||
let dst = State(dst);
|
||||
let old = transitions.entry(src).or_default().byte_transitions.insert(edge.into(), dst);
|
||||
assert!(old.is_none());
|
||||
}
|
||||
|
||||
Self { start, accept, transitions }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl<R> From<nfa::Transition<R>> for Transition<R>
|
||||
/// Serialize the DFA using the Graphviz DOT format.
|
||||
impl<R> fmt::Debug for Dfa<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
fn from(nfa_transition: nfa::Transition<R>) -> Self {
|
||||
match nfa_transition {
|
||||
nfa::Transition::Byte(byte) => Transition::Byte(byte),
|
||||
nfa::Transition::Ref(r) => Transition::Ref(r),
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
writeln!(f, "digraph {{")?;
|
||||
writeln!(f, " {:?} [shape = doublecircle]", self.start)?;
|
||||
writeln!(f, " {:?} [shape = doublecircle]", self.accept)?;
|
||||
|
||||
for (src, transitions) in self.transitions.iter() {
|
||||
for (t, dst) in transitions.byte_transitions.iter() {
|
||||
writeln!(f, " {src:?} -> {dst:?} [label=\"{t:?}\"]")?;
|
||||
}
|
||||
|
||||
for (t, dst) in transitions.ref_transitions.iter() {
|
||||
writeln!(f, " {src:?} -> {dst:?} [label=\"{t:?}\"]")?;
|
||||
}
|
||||
}
|
||||
|
||||
writeln!(f, "}}")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,9 +4,6 @@ use std::hash::Hash;
|
|||
pub(crate) mod tree;
|
||||
pub(crate) use tree::Tree;
|
||||
|
||||
pub(crate) mod nfa;
|
||||
pub(crate) use nfa::Nfa;
|
||||
|
||||
pub(crate) mod dfa;
|
||||
pub(crate) use dfa::Dfa;
|
||||
|
||||
|
|
@ -29,6 +26,13 @@ impl fmt::Debug for Byte {
|
|||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
impl From<u8> for Byte {
|
||||
fn from(src: u8) -> Self {
|
||||
Self::Init(src)
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) trait Def: Debug + Hash + Eq + PartialEq + Copy + Clone {
|
||||
fn has_safety_invariants(&self) -> bool;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,169 +0,0 @@
|
|||
use std::fmt;
|
||||
use std::sync::atomic::{AtomicU32, Ordering};
|
||||
|
||||
use super::{Byte, Ref, Tree, Uninhabited};
|
||||
use crate::{Map, Set};
|
||||
|
||||
/// A non-deterministic finite automaton (NFA) that represents the layout of a type.
|
||||
/// The transmutability of two given types is computed by comparing their `Nfa`s.
|
||||
#[derive(PartialEq, Debug)]
|
||||
pub(crate) struct Nfa<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
pub(crate) transitions: Map<State, Map<Transition<R>, Set<State>>>,
|
||||
pub(crate) start: State,
|
||||
pub(crate) accepting: State,
|
||||
}
|
||||
|
||||
/// The states in a `Nfa` represent byte offsets.
|
||||
#[derive(Hash, Eq, PartialEq, PartialOrd, Ord, Copy, Clone)]
|
||||
pub(crate) struct State(u32);
|
||||
|
||||
/// The transitions between states in a `Nfa` reflect bit validity.
|
||||
#[derive(Hash, Eq, PartialEq, Clone, Copy)]
|
||||
pub(crate) enum Transition<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
Byte(Byte),
|
||||
Ref(R),
|
||||
}
|
||||
|
||||
impl fmt::Debug for State {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "S_{}", self.0)
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> fmt::Debug for Transition<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match &self {
|
||||
Self::Byte(b) => b.fmt(f),
|
||||
Self::Ref(r) => r.fmt(f),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<R> Nfa<R>
|
||||
where
|
||||
R: Ref,
|
||||
{
|
||||
pub(crate) fn unit() -> Self {
|
||||
let transitions: Map<State, Map<Transition<R>, Set<State>>> = Map::default();
|
||||
let start = State::new();
|
||||
let accepting = start;
|
||||
|
||||
Nfa { transitions, start, accepting }
|
||||
}
|
||||
|
||||
pub(crate) fn from_byte(byte: Byte) -> Self {
|
||||
let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = Map::default();
|
||||
let start = State::new();
|
||||
let accepting = State::new();
|
||||
|
||||
let source = transitions.entry(start).or_default();
|
||||
let edge = source.entry(Transition::Byte(byte)).or_default();
|
||||
edge.insert(accepting);
|
||||
|
||||
Nfa { transitions, start, accepting }
|
||||
}
|
||||
|
||||
pub(crate) fn from_ref(r: R) -> Self {
|
||||
let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = Map::default();
|
||||
let start = State::new();
|
||||
let accepting = State::new();
|
||||
|
||||
let source = transitions.entry(start).or_default();
|
||||
let edge = source.entry(Transition::Ref(r)).or_default();
|
||||
edge.insert(accepting);
|
||||
|
||||
Nfa { transitions, start, accepting }
|
||||
}
|
||||
|
||||
pub(crate) fn from_tree(tree: Tree<!, R>) -> Result<Self, Uninhabited> {
|
||||
Ok(match tree {
|
||||
Tree::Byte(b) => Self::from_byte(b),
|
||||
Tree::Ref(r) => Self::from_ref(r),
|
||||
Tree::Alt(alts) => {
|
||||
let mut alts = alts.into_iter().map(Self::from_tree);
|
||||
let mut nfa = alts.next().ok_or(Uninhabited)??;
|
||||
for alt in alts {
|
||||
nfa = nfa.union(alt?);
|
||||
}
|
||||
nfa
|
||||
}
|
||||
Tree::Seq(elts) => {
|
||||
let mut nfa = Self::unit();
|
||||
for elt in elts.into_iter().map(Self::from_tree) {
|
||||
nfa = nfa.concat(elt?);
|
||||
}
|
||||
nfa
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Concatenate two `Nfa`s.
|
||||
pub(crate) fn concat(self, other: Self) -> Self {
|
||||
if self.start == self.accepting {
|
||||
return other;
|
||||
} else if other.start == other.accepting {
|
||||
return self;
|
||||
}
|
||||
|
||||
let start = self.start;
|
||||
let accepting = other.accepting;
|
||||
|
||||
let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = self.transitions;
|
||||
|
||||
for (source, transition) in other.transitions {
|
||||
let fix_state = |state| if state == other.start { self.accepting } else { state };
|
||||
let entry = transitions.entry(fix_state(source)).or_default();
|
||||
for (edge, destinations) in transition {
|
||||
let entry = entry.entry(edge).or_default();
|
||||
for destination in destinations {
|
||||
entry.insert(fix_state(destination));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Self { transitions, start, accepting }
|
||||
}
|
||||
|
||||
/// Compute the union of two `Nfa`s.
|
||||
pub(crate) fn union(self, other: Self) -> Self {
|
||||
let start = self.start;
|
||||
let accepting = self.accepting;
|
||||
|
||||
let mut transitions: Map<State, Map<Transition<R>, Set<State>>> = self.transitions.clone();
|
||||
|
||||
for (&(mut source), transition) in other.transitions.iter() {
|
||||
// if source is starting state of `other`, replace with starting state of `self`
|
||||
if source == other.start {
|
||||
source = self.start;
|
||||
}
|
||||
let entry = transitions.entry(source).or_default();
|
||||
for (edge, destinations) in transition {
|
||||
let entry = entry.entry(*edge).or_default();
|
||||
for &(mut destination) in destinations {
|
||||
// if dest is accepting state of `other`, replace with accepting state of `self`
|
||||
if destination == other.accepting {
|
||||
destination = self.accepting;
|
||||
}
|
||||
entry.insert(destination);
|
||||
}
|
||||
}
|
||||
}
|
||||
Self { transitions, start, accepting }
|
||||
}
|
||||
}
|
||||
|
||||
impl State {
|
||||
pub(crate) fn new() -> Self {
|
||||
static COUNTER: AtomicU32 = AtomicU32::new(0);
|
||||
Self(COUNTER.fetch_add(1, Ordering::SeqCst))
|
||||
}
|
||||
}
|
||||
|
|
@ -2,7 +2,7 @@
|
|||
#![feature(never_type)]
|
||||
// tidy-alphabetical-end
|
||||
|
||||
pub(crate) use rustc_data_structures::fx::{FxIndexMap as Map, FxIndexSet as Set};
|
||||
pub(crate) use rustc_data_structures::fx::FxIndexMap as Map;
|
||||
|
||||
pub mod layout;
|
||||
mod maybe_transmutable;
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ pub(crate) mod query_context;
|
|||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use crate::layout::{self, Byte, Def, Dfa, Nfa, Ref, Tree, Uninhabited, dfa};
|
||||
use crate::layout::{self, Byte, Def, Dfa, Ref, Tree, Uninhabited, dfa};
|
||||
use crate::maybe_transmutable::query_context::QueryContext;
|
||||
use crate::{Answer, Condition, Map, Reason};
|
||||
|
||||
|
|
@ -73,7 +73,7 @@ where
|
|||
/// Answers whether a `Tree` is transmutable into another `Tree`.
|
||||
///
|
||||
/// This method begins by de-def'ing `src` and `dst`, and prunes private paths from `dst`,
|
||||
/// then converts `src` and `dst` to `Nfa`s, and computes an answer using those NFAs.
|
||||
/// then converts `src` and `dst` to `Dfa`s, and computes an answer using those DFAs.
|
||||
#[inline(always)]
|
||||
#[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))]
|
||||
pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
|
||||
|
|
@ -105,22 +105,22 @@ where
|
|||
|
||||
trace!(?dst, "pruned dst");
|
||||
|
||||
// Convert `src` from a tree-based representation to an NFA-based
|
||||
// Convert `src` from a tree-based representation to an DFA-based
|
||||
// representation. If the conversion fails because `src` is uninhabited,
|
||||
// conclude that the transmutation is acceptable, because instances of
|
||||
// the `src` type do not exist.
|
||||
let src = match Nfa::from_tree(src) {
|
||||
let src = match Dfa::from_tree(src) {
|
||||
Ok(src) => src,
|
||||
Err(Uninhabited) => return Answer::Yes,
|
||||
};
|
||||
|
||||
// Convert `dst` from a tree-based representation to an NFA-based
|
||||
// Convert `dst` from a tree-based representation to an DFA-based
|
||||
// representation. If the conversion fails because `src` is uninhabited,
|
||||
// conclude that the transmutation is unacceptable. Valid instances of
|
||||
// the `dst` type do not exist, either because it's genuinely
|
||||
// uninhabited, or because there are no branches of the tree that are
|
||||
// free of safety invariants.
|
||||
let dst = match Nfa::from_tree(dst) {
|
||||
let dst = match Dfa::from_tree(dst) {
|
||||
Ok(dst) => dst,
|
||||
Err(Uninhabited) => return Answer::No(Reason::DstMayHaveSafetyInvariants),
|
||||
};
|
||||
|
|
@ -129,23 +129,6 @@ where
|
|||
}
|
||||
}
|
||||
|
||||
impl<C> MaybeTransmutableQuery<Nfa<<C as QueryContext>::Ref>, C>
|
||||
where
|
||||
C: QueryContext,
|
||||
{
|
||||
/// Answers whether a `Nfa` is transmutable into another `Nfa`.
|
||||
///
|
||||
/// This method converts `src` and `dst` to DFAs, then computes an answer using those DFAs.
|
||||
#[inline(always)]
|
||||
#[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))]
|
||||
pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
|
||||
let Self { src, dst, assume, context } = self;
|
||||
let src = Dfa::from_nfa(src);
|
||||
let dst = Dfa::from_nfa(dst);
|
||||
MaybeTransmutableQuery { src, dst, assume, context }.answer()
|
||||
}
|
||||
}
|
||||
|
||||
impl<C> MaybeTransmutableQuery<Dfa<<C as QueryContext>::Ref>, C>
|
||||
where
|
||||
C: QueryContext,
|
||||
|
|
@ -173,7 +156,7 @@ where
|
|||
src_transitions_len = self.src.transitions.len(),
|
||||
dst_transitions_len = self.dst.transitions.len()
|
||||
);
|
||||
let answer = if dst_state == self.dst.accepting {
|
||||
let answer = if dst_state == self.dst.accept {
|
||||
// truncation: `size_of(Src) >= size_of(Dst)`
|
||||
//
|
||||
// Why is truncation OK to do? Because even though the Src is bigger, all we care about
|
||||
|
|
@ -190,7 +173,7 @@ where
|
|||
// that none of the actually-used data can introduce an invalid state for Dst's type, we
|
||||
// are able to safely transmute, even with truncation.
|
||||
Answer::Yes
|
||||
} else if src_state == self.src.accepting {
|
||||
} else if src_state == self.src.accept {
|
||||
// extension: `size_of(Src) >= size_of(Dst)`
|
||||
if let Some(dst_state_prime) = self.dst.byte_from(dst_state, Byte::Uninit) {
|
||||
self.answer_memo(cache, src_state, dst_state_prime)
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ mod bool {
|
|||
|
||||
let into_set = |alts: Vec<_>| {
|
||||
#[cfg(feature = "rustc")]
|
||||
let mut set = crate::Set::default();
|
||||
let mut set = rustc_data_structures::fx::FxIndexSet::default();
|
||||
#[cfg(not(feature = "rustc"))]
|
||||
let mut set = std::collections::HashSet::new();
|
||||
set.extend(alts);
|
||||
|
|
@ -174,3 +174,32 @@ mod bool {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
mod union {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn union() {
|
||||
let [a, b, c, d] = [0, 1, 2, 3];
|
||||
let s = Dfa::from_edges(a, d, &[(a, 0, b), (b, 0, d), (a, 1, c), (c, 1, d)]);
|
||||
|
||||
let t = Dfa::from_edges(a, c, &[(a, 1, b), (b, 0, c)]);
|
||||
|
||||
let mut ctr = 0;
|
||||
let new_state = || {
|
||||
let state = crate::layout::dfa::State(ctr);
|
||||
ctr += 1;
|
||||
state
|
||||
};
|
||||
|
||||
let u = s.clone().union(t.clone(), new_state);
|
||||
|
||||
let expected_u =
|
||||
Dfa::from_edges(b, a, &[(b, 0, c), (b, 1, d), (d, 1, a), (d, 0, a), (c, 0, a)]);
|
||||
|
||||
assert_eq!(u, expected_u);
|
||||
|
||||
assert_eq!(is_transmutable(&s, &u, Assume::default()), Answer::Yes);
|
||||
assert_eq!(is_transmutable(&t, &u, Assume::default()), Answer::Yes);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -304,7 +304,7 @@ pub unsafe fn simd_shuffle<T, U, V>(x: T, y: T, idx: U) -> V;
|
|||
///
|
||||
/// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`.
|
||||
///
|
||||
/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
|
||||
/// `V` must be a vector of integers with the same length as `T` (but any element size).
|
||||
///
|
||||
/// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, read the pointer.
|
||||
/// Otherwise if the corresponding value in `mask` is `0`, return the corresponding value from
|
||||
|
|
@ -325,7 +325,7 @@ pub unsafe fn simd_gather<T, U, V>(val: T, ptr: U, mask: V) -> T;
|
|||
///
|
||||
/// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`.
|
||||
///
|
||||
/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
|
||||
/// `V` must be a vector of integers with the same length as `T` (but any element size).
|
||||
///
|
||||
/// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, write the
|
||||
/// corresponding value in `val` to the pointer.
|
||||
|
|
@ -349,7 +349,7 @@ pub unsafe fn simd_scatter<T, U, V>(val: T, ptr: U, mask: V);
|
|||
///
|
||||
/// `U` must be a pointer to the element type of `T`
|
||||
///
|
||||
/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
|
||||
/// `V` must be a vector of integers with the same length as `T` (but any element size).
|
||||
///
|
||||
/// For each element, if the corresponding value in `mask` is `!0`, read the corresponding
|
||||
/// pointer offset from `ptr`.
|
||||
|
|
@ -372,7 +372,7 @@ pub unsafe fn simd_masked_load<V, U, T>(mask: V, ptr: U, val: T) -> T;
|
|||
///
|
||||
/// `U` must be a pointer to the element type of `T`
|
||||
///
|
||||
/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
|
||||
/// `V` must be a vector of integers with the same length as `T` (but any element size).
|
||||
///
|
||||
/// For each element, if the corresponding value in `mask` is `!0`, write the corresponding
|
||||
/// value in `val` to the pointer offset from `ptr`.
|
||||
|
|
@ -556,7 +556,7 @@ pub unsafe fn simd_bitmask<T, U>(x: T) -> U;
|
|||
///
|
||||
/// `T` must be a vector.
|
||||
///
|
||||
/// `M` must be a signed integer vector with the same length as `T` (but any element size).
|
||||
/// `M` must be an integer vector with the same length as `T` (but any element size).
|
||||
///
|
||||
/// For each element, if the corresponding value in `mask` is `!0`, select the element from
|
||||
/// `if_true`. If the corresponding value in `mask` is `0`, select the element from
|
||||
|
|
|
|||
|
|
@ -2814,7 +2814,7 @@ impl<T> [T] {
|
|||
let half = size / 2;
|
||||
let mid = base + half;
|
||||
|
||||
// SAFETY: the call is made safe by the following inconstants:
|
||||
// SAFETY: the call is made safe by the following invariants:
|
||||
// - `mid >= 0`: by definition
|
||||
// - `mid < size`: `mid = size / 2 + size / 4 + size / 8 ...`
|
||||
let cmp = f(unsafe { self.get_unchecked(mid) });
|
||||
|
|
|
|||
|
|
@ -43,13 +43,13 @@ rustdocs][rustdocs].
|
|||
To build a local static HTML site, install [`mdbook`](https://github.com/rust-lang/mdBook) with:
|
||||
|
||||
```
|
||||
> cargo install mdbook mdbook-linkcheck2 mdbook-toc mdbook-mermaid
|
||||
cargo install mdbook mdbook-linkcheck2 mdbook-toc mdbook-mermaid
|
||||
```
|
||||
|
||||
and execute the following command in the root of the repository:
|
||||
|
||||
```
|
||||
> mdbook build --open
|
||||
mdbook build --open
|
||||
```
|
||||
|
||||
The build files are found in the `book/html` directory.
|
||||
|
|
@ -61,8 +61,8 @@ checking is **not** run by default locally, though it is in CI. To enable it
|
|||
locally, set the environment variable `ENABLE_LINKCHECK=1` like in the
|
||||
following example.
|
||||
|
||||
```console
|
||||
$ ENABLE_LINKCHECK=1 mdbook serve
|
||||
```
|
||||
ENABLE_LINKCHECK=1 mdbook serve
|
||||
```
|
||||
|
||||
### Table of Contents
|
||||
|
|
@ -86,14 +86,14 @@ Older versions of `josh-proxy` may not round trip commits losslessly so it is im
|
|||
1) Checkout a new branch that will be used to create a PR into `rust-lang/rustc-dev-guide`
|
||||
2) Run the pull command
|
||||
```
|
||||
$ cargo run --manifest-path josh-sync/Cargo.toml rustc-pull
|
||||
cargo run --manifest-path josh-sync/Cargo.toml rustc-pull
|
||||
```
|
||||
3) Push the branch to your fork and create a PR into `rustc-dev-guide`
|
||||
|
||||
### Push changes from this repository into `rust-lang/rust`
|
||||
1) Run the push command to create a branch named `<branch-name>` in a `rustc` fork under the `<gh-username>` account
|
||||
```
|
||||
$ cargo run --manifest-path josh-sync/Cargo.toml rustc-push <branch-name> <gh-username>
|
||||
cargo run --manifest-path josh-sync/Cargo.toml rustc-push <branch-name> <gh-username>
|
||||
```
|
||||
2) Create a PR from `<branch-name>` into `rust-lang/rust`
|
||||
|
||||
|
|
@ -106,5 +106,5 @@ You may observe "Nothing to pull" even if you *know* rustc-pull has something to
|
|||
To minimize the likelihood of this happening, you may wish to keep a separate *minimal* git config that *only* has `[user]` entries from global git config, then repoint system git to use the minimal git config instead. E.g.
|
||||
|
||||
```
|
||||
$ GIT_CONFIG_GLOBAL=/path/to/minimal/gitconfig GIT_CONFIG_SYSTEM='' cargo +stable run --manifest-path josh-sync/Cargo.toml -- rustc-pull
|
||||
GIT_CONFIG_GLOBAL=/path/to/minimal/gitconfig GIT_CONFIG_SYSTEM='' cargo +stable run --manifest-path josh-sync/Cargo.toml -- rustc-pull
|
||||
```
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
25a615bf829b9f6d6f22da537e3851043f92e5f2
|
||||
a7c39b68616668a45f0afd62849a1da7c8ad2516
|
||||
|
|
|
|||
|
|
@ -10,9 +10,9 @@
|
|||
- [How to build and run the compiler](./building/how-to-build-and-run.md)
|
||||
- [Quickstart](./building/quickstart.md)
|
||||
- [Prerequisites](./building/prerequisites.md)
|
||||
- [Suggested Workflows](./building/suggested.md)
|
||||
- [Suggested workflows](./building/suggested.md)
|
||||
- [Distribution artifacts](./building/build-install-distribution-artifacts.md)
|
||||
- [Building Documentation](./building/compiler-documenting.md)
|
||||
- [Building documentation](./building/compiler-documenting.md)
|
||||
- [Rustdoc overview](./rustdoc.md)
|
||||
- [Adding a new target](./building/new-target.md)
|
||||
- [Optimized build](./building/optimized-build.md)
|
||||
|
|
@ -42,11 +42,11 @@
|
|||
- [with the linux perf tool](./profiling/with_perf.md)
|
||||
- [with Windows Performance Analyzer](./profiling/wpa_profiling.md)
|
||||
- [with the Rust benchmark suite](./profiling/with_rustc_perf.md)
|
||||
- [crates.io Dependencies](./crates-io.md)
|
||||
- [crates.io dependencies](./crates-io.md)
|
||||
|
||||
# Contributing to Rust
|
||||
|
||||
- [Contribution Procedures](./contributing.md)
|
||||
- [Contribution procedures](./contributing.md)
|
||||
- [About the compiler team](./compiler-team.md)
|
||||
- [Using Git](./git.md)
|
||||
- [Mastering @rustbot](./rustbot.md)
|
||||
|
|
@ -56,7 +56,7 @@
|
|||
- [Stabilizing Features](./stabilization_guide.md)
|
||||
- [Feature Gates](./feature-gates.md)
|
||||
- [Coding conventions](./conventions.md)
|
||||
- [Procedures for Breaking Changes](./bug-fix-procedure.md)
|
||||
- [Procedures for breaking changes](./bug-fix-procedure.md)
|
||||
- [Using external repositories](./external-repos.md)
|
||||
- [Fuzzing](./fuzzing.md)
|
||||
- [Notification groups](notification-groups/about.md)
|
||||
|
|
@ -81,6 +81,7 @@
|
|||
- [How Bootstrap does it](./building/bootstrapping/how-bootstrap-does-it.md)
|
||||
- [Writing tools in Bootstrap](./building/bootstrapping/writing-tools-in-bootstrap.md)
|
||||
- [Debugging bootstrap](./building/bootstrapping/debugging-bootstrap.md)
|
||||
- [cfg(bootstrap) in dependencies](./building/bootstrapping/bootstrap-in-dependencies.md)
|
||||
|
||||
# High-level Compiler Architecture
|
||||
|
||||
|
|
@ -88,29 +89,35 @@
|
|||
- [Overview of the compiler](./overview.md)
|
||||
- [The compiler source code](./compiler-src.md)
|
||||
- [Queries: demand-driven compilation](./query.md)
|
||||
- [The Query Evaluation Model in Detail](./queries/query-evaluation-model-in-detail.md)
|
||||
- [The Query Evaluation Model in detail](./queries/query-evaluation-model-in-detail.md)
|
||||
- [Incremental compilation](./queries/incremental-compilation.md)
|
||||
- [Incremental compilation In Detail](./queries/incremental-compilation-in-detail.md)
|
||||
- [Debugging and Testing](./incrcomp-debugging.md)
|
||||
- [Incremental compilation in detail](./queries/incremental-compilation-in-detail.md)
|
||||
- [Debugging and testing](./incrcomp-debugging.md)
|
||||
- [Salsa](./queries/salsa.md)
|
||||
- [Memory Management in Rustc](./memory.md)
|
||||
- [Serialization in Rustc](./serialization.md)
|
||||
- [Parallel Compilation](./parallel-rustc.md)
|
||||
- [Memory management in rustc](./memory.md)
|
||||
- [Serialization in rustc](./serialization.md)
|
||||
- [Parallel compilation](./parallel-rustc.md)
|
||||
- [Rustdoc internals](./rustdoc-internals.md)
|
||||
- [Search](./rustdoc-internals/search.md)
|
||||
- [The `rustdoc` test suite](./rustdoc-internals/rustdoc-test-suite.md)
|
||||
- [Autodiff internals](./autodiff/internals.md)
|
||||
- [Installation](./autodiff/installation.md)
|
||||
- [How to debug](./autodiff/debugging.md)
|
||||
- [Autodiff flags](./autodiff/flags.md)
|
||||
- [Current limitations](./autodiff/limitations.md)
|
||||
|
||||
# Source Code Representation
|
||||
|
||||
- [Prologue](./part-3-intro.md)
|
||||
- [Syntax and the AST](./syntax-intro.md)
|
||||
- [Lexing and Parsing](./the-parser.md)
|
||||
- [Lexing and parsing](./the-parser.md)
|
||||
- [Macro expansion](./macro-expansion.md)
|
||||
- [Name resolution](./name-resolution.md)
|
||||
- [Attributes](./attributes.md)
|
||||
- [`#[test]` Implementation](./test-implementation.md)
|
||||
- [Panic Implementation](./panic-implementation.md)
|
||||
- [AST Validation](./ast-validation.md)
|
||||
- [Feature Gate Checking](./feature-gate-ck.md)
|
||||
- [`#[test]` implementation](./test-implementation.md)
|
||||
- [Panic implementation](./panic-implementation.md)
|
||||
- [AST validation](./ast-validation.md)
|
||||
- [Feature gate checking](./feature-gate-ck.md)
|
||||
- [Lang Items](./lang-items.md)
|
||||
- [The HIR (High-level IR)](./hir.md)
|
||||
- [Lowering AST to HIR](./ast-lowering.md)
|
||||
|
|
@ -129,7 +136,7 @@
|
|||
- [Example: Type checking](./rustc-driver/interacting-with-the-ast.md)
|
||||
- [Example: Getting diagnostics](./rustc-driver/getting-diagnostics.md)
|
||||
- [Remarks on perma-unstable features](./rustc-driver/remarks-on-perma-unstable-features.md)
|
||||
- [Errors and Lints](diagnostics.md)
|
||||
- [Errors and lints](diagnostics.md)
|
||||
- [Diagnostic and subdiagnostic structs](./diagnostics/diagnostic-structs.md)
|
||||
- [Translation](./diagnostics/translation.md)
|
||||
- [`LintStore`](./diagnostics/lintstore.md)
|
||||
|
|
@ -175,14 +182,14 @@
|
|||
- [Type checking](./type-checking.md)
|
||||
- [Method Lookup](./method-lookup.md)
|
||||
- [Variance](./variance.md)
|
||||
- [Coherence Checking](./coherence.md)
|
||||
- [Opaque Types](./opaque-types-type-alias-impl-trait.md)
|
||||
- [Coherence checking](./coherence.md)
|
||||
- [Opaque types](./opaque-types-type-alias-impl-trait.md)
|
||||
- [Inference details](./opaque-types-impl-trait-inference.md)
|
||||
- [Return Position Impl Trait In Trait](./return-position-impl-trait-in-trait.md)
|
||||
- [Region inference restrictions][opaque-infer]
|
||||
- [Const condition checking](./effects.md)
|
||||
- [Pattern and Exhaustiveness Checking](./pat-exhaustive-checking.md)
|
||||
- [Unsafety Checking](./unsafety-checking.md)
|
||||
- [Unsafety checking](./unsafety-checking.md)
|
||||
- [MIR dataflow](./mir/dataflow.md)
|
||||
- [Drop elaboration](./mir/drop-elaboration.md)
|
||||
- [The borrow checker](./borrow_check.md)
|
||||
|
|
|
|||
|
|
@ -3,33 +3,41 @@
|
|||
This guide is meant to help document how rustc – the Rust compiler – works,
|
||||
as well as to help new contributors get involved in rustc development.
|
||||
|
||||
There are seven parts to this guide:
|
||||
There are several parts to this guide:
|
||||
|
||||
1. [Building `rustc`][p1]:
|
||||
1. [Building and debugging `rustc`][p1]:
|
||||
Contains information that should be useful no matter how you are contributing,
|
||||
about building, debugging, profiling, etc.
|
||||
2. [Contributing to `rustc`][p2]:
|
||||
1. [Contributing to Rust][p2]:
|
||||
Contains information that should be useful no matter how you are contributing,
|
||||
about procedures for contribution, using git and Github, stabilizing features, etc.
|
||||
3. [High-Level Compiler Architecture][p3]:
|
||||
1. [Bootstrapping][p3]:
|
||||
Describes how the Rust compiler builds itself using previous versions, including
|
||||
an introduction to the bootstrap process and debugging methods.
|
||||
1. [High-level Compiler Architecture][p4]:
|
||||
Discusses the high-level architecture of the compiler and stages of the compile process.
|
||||
4. [Source Code Representation][p4]:
|
||||
1. [Source Code Representation][p5]:
|
||||
Describes the process of taking raw source code from the user
|
||||
and transforming it into various forms that the compiler can work with easily.
|
||||
5. [Analysis][p5]:
|
||||
discusses the analyses that the compiler uses to check various properties of the code
|
||||
1. [Supporting Infrastructure][p6]:
|
||||
Covers command-line argument conventions, compiler entry points like rustc_driver and
|
||||
rustc_interface, and the design and implementation of errors and lints.
|
||||
1. [Analysis][p7]:
|
||||
Discusses the analyses that the compiler uses to check various properties of the code
|
||||
and inform later stages of the compile process (e.g., type checking).
|
||||
6. [From MIR to Binaries][p6]: How linked executable machine code is generated.
|
||||
7. [Appendices][p7] at the end with useful reference information.
|
||||
1. [MIR to Binaries][p8]: How linked executable machine code is generated.
|
||||
1. [Appendices][p9] at the end with useful reference information.
|
||||
There are a few of these with different information, including a glossary.
|
||||
|
||||
[p1]: ./building/how-to-build-and-run.html
|
||||
[p2]: ./contributing.md
|
||||
[p3]: ./part-2-intro.md
|
||||
[p4]: ./part-3-intro.md
|
||||
[p5]: ./part-4-intro.md
|
||||
[p6]: ./part-5-intro.md
|
||||
[p7]: ./appendix/background.md
|
||||
[p3]: ./building/bootstrapping/intro.md
|
||||
[p4]: ./part-2-intro.md
|
||||
[p5]: ./part-3-intro.md
|
||||
[p6]: ./cli.md
|
||||
[p7]: ./part-4-intro.md
|
||||
[p8]: ./part-5-intro.md
|
||||
[p9]: ./appendix/background.md
|
||||
|
||||
### Constant change
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# AST Validation
|
||||
# AST validation
|
||||
|
||||
_AST validation_ is a separate AST pass that visits each
|
||||
item in the tree and performs simple checks. This pass
|
||||
|
|
|
|||
113
src/doc/rustc-dev-guide/src/autodiff/debugging.md
Normal file
113
src/doc/rustc-dev-guide/src/autodiff/debugging.md
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
# Reporting backend crashes
|
||||
|
||||
If after a compilation failure you are greeted by a large amount of llvm-ir code, then our enzyme backend likely failed to compile your code. These cases are harder to debug, so your help is highly appreciated. Please also keep in mind that release builds are usually much more likely to work at the moment.
|
||||
|
||||
The final goal here is to reproduce your bug in the enzyme [compiler explorer](https://enzyme.mit.edu/explorer/), in order to create a bug report in the [Enzyme](https://github.com/enzymead/enzyme/issues) repository.
|
||||
|
||||
We have an `autodiff` flag which you can pass to `rustflags` to help with this. it will print the whole llvm-ir module, along with some `__enzyme_fwddiff` or `__enzyme_autodiff` calls. A potential workflow on linux could look like:
|
||||
|
||||
## Controlling llvm-ir generation
|
||||
|
||||
Before generating the llvm-ir, keep in mind two techniques that can help ensure the relevant rust code is visible for debugging:
|
||||
|
||||
- **`std::hint::black_box`**: wrap rust variables or expressions in `std::hint::black_box()` to prevent rust and llvm from optimizing them away. This is useful when you need to inspect or manually manipulate specific values in the llvm-ir.
|
||||
- **`extern "rust"` or `extern "c"`**: if you want to see how a specific function declaration is lowered to llvm-ir, you can declare it as `extern "rust"` or `extern "c"`. You can also look for existing `__enzyme_autodiff` or similar declarations within the generated module for examples.
|
||||
|
||||
## 1) Generate an llvm-ir reproducer
|
||||
|
||||
```sh
|
||||
rustflags="-z autodiff=enable,printmodbefore" cargo +enzyme build --release &> out.ll
|
||||
```
|
||||
|
||||
This also captures a few warnings and info messages above and below your module. open out.ll and remove every line above `; moduleid = <somehash>`. Now look at the end of the file and remove everything that's not part of llvm-ir, i.e. remove errors and warnings. The last line of your llvm-ir should now start with `!<somenumber> = `, i.e. `!40831 = !{i32 0, i32 1037508, i32 1037538, i32 1037559}` or `!43760 = !dilocation(line: 297, column: 5, scope: !43746)`.
|
||||
|
||||
The actual numbers will depend on your code.
|
||||
|
||||
## 2) Check your llvm-ir reproducer
|
||||
|
||||
To confirm that your previous step worked, we will use llvm's `opt` tool. find your path to the opt binary, with a path similar to `<some_dir>/rust/build/<x86/arm/...-target-tripple>/build/bin/opt`. also find `llvmenzyme-19.<so/dll/dylib>` path, similar to `/rust/build/target-tripple/enzyme/build/enzyme/llvmenzyme-19`. Please keep in mind that llvm frequently updates it's llvm backend, so the version number might be higher (20, 21, ...). Once you have both, run the following command:
|
||||
|
||||
```sh
|
||||
<path/to/opt> out.ll -load-pass-plugin=/path/to/llvmenzyme-19.so -passes="enzyme" -s
|
||||
```
|
||||
|
||||
If the previous step succeeded, you are going to see the same error that you saw when compiling your rust code with cargo.
|
||||
|
||||
If you fail to get the same error, please open an issue in the rust repository. If you succeed, congrats! the file is still huge, so let's automatically minimize it.
|
||||
|
||||
## 3) Minimize your llvm-ir reproducer
|
||||
|
||||
First find your `llvm-extract` binary, it's in the same folder as your opt binary. then run:
|
||||
|
||||
```sh
|
||||
<path/to/llvm-extract> -s --func=<name> --recursive --rfunc="enzyme_autodiff*" --rfunc="enzyme_fwddiff*" --rfunc=<fnc_called_by_enzyme> out.ll -o mwe.ll
|
||||
```
|
||||
|
||||
This command creates `mwe.ll`, a minimal working example.
|
||||
|
||||
Please adjust the name passed with the last `--func` flag. You can either apply the `#[no_mangle]` attribute to the function you differentiate, then you can replace it with the rust name. otherwise you will need to look up the mangled function name. To do that, open `out.ll` and search for `__enzyme_fwddiff` or `__enzyme_autodiff`. the first string in that function call is the name of your function. example:
|
||||
|
||||
```llvm-ir
|
||||
define double @enzyme_opt_helper_0(ptr %0, i64 %1, double %2) {
|
||||
%4 = call double (...) @__enzyme_fwddiff(ptr @_zn2ad3_f217h3b3b1800bd39fde3e, metadata !"enzyme_const", ptr %0, metadata !"enzyme_const", i64 %1, metadata !"enzyme_dup", double %2, double %2)
|
||||
ret double %4
|
||||
}
|
||||
```
|
||||
|
||||
Here, `_zn2ad3_f217h3b3b1800bd39fde3e` is the correct name. make sure to not copy the leading `@`. redo step 2) by running the `opt` command again, but this time passing `mwe.ll` as the input file instead of `out.ll`. Check if this minimized example still reproduces the crash.
|
||||
|
||||
## 4) (Optional) Minimize your llvm-ir reproducer further.
|
||||
|
||||
After the previous step you should have an `mwe.ll` file with ~5k loc. let's try to get it down to 50. find your `llvm-reduce` binary next to `opt` and `llvm-extract`. Copy the first line of your error message, an example could be:
|
||||
|
||||
```sh
|
||||
opt: /home/manuel/prog/rust/src/llvm-project/llvm/lib/ir/instructions.cpp:686: void llvm::callinst::init(llvm::functiontype*, llvm::value*, llvm::arrayref<llvm::value*>, llvm::arrayref<llvm::operandbundledeft<llvm::value*> >, const llvm::twine&): assertion `(args.size() == fty->getnumparams() || (fty->isvararg() && args.size() > fty->getnumparams())) && "calling a function with bad signature!"' failed.
|
||||
```
|
||||
|
||||
If you just get a `segfault` there is no sensible error message and not much to do automatically, so continue to 5).
|
||||
otherwise, create a `script.sh` file containing
|
||||
|
||||
```sh
|
||||
#!/bin/bash
|
||||
<path/to/your/opt> $1 -load-pass-plugin=/path/to/llvmenzyme-19.so -passes="enzyme" \
|
||||
|& grep "/some/path.cpp:686: void llvm::callinst::init"
|
||||
```
|
||||
|
||||
Experiment a bit with which error message you pass to grep. it should be long enough to make sure that the error is unique. However, for longer errors including `(` or `)` you will need to escape them correctly which can become annoying. Run
|
||||
|
||||
```sh
|
||||
<path/to/llvm-reduce> --test=script.sh mwe.ll
|
||||
```
|
||||
|
||||
If you see `input isn't interesting! verify interesting-ness test`, you got the error message in script.sh wrong, you need to make sure that grep matches your actual error. If all works out, you will see a lot of iterations, ending with a new `reduced.ll` file. Verify with `opt` that you still get the same error.
|
||||
|
||||
### Advanced debugging: manual llvm-ir investigation
|
||||
|
||||
Once you have a minimized reproducer (`mwe.ll` or `reduced.ll`), you can delve deeper:
|
||||
|
||||
- **manual editing:** try manually rewriting the llvm-ir. for certain issues, like those involving indirect calls, you might investigate enzyme-specific intrinsics like `__enzyme_virtualreverse`. Understanding how to use these might require consulting enzyme's documentation or source code.
|
||||
- **enzyme test cases:** look for relevant test cases within the [enzyme repository](https://github.com/enzymead/enzyme/tree/main/enzyme/test) that might demonstrate the correct usage of features or intrinsics related to your problem.
|
||||
|
||||
## 5) Report your bug.
|
||||
|
||||
Afterwards, you should be able to copy and paste your `mwe.ll` (or `reduced.ll`) example into our [compiler explorer](https://enzyme.mit.edu/explorer/).
|
||||
|
||||
- Select `llvm ir` as language and `opt 20` as compiler.
|
||||
- Replace the field to the right of your compiler with `-passes="enzyme"`, if it is not already set.
|
||||
- Hopefully, you will see once again your now familiar error.
|
||||
- Please use the share button to copy links to them.
|
||||
- Please create an issue on [https://github.com/enzymead/enzyme/issues](https://github.com/enzymead/enzyme/issues) and share `mwe.ll` and (if you have it) `reduced.ll`, as well as links to the compiler explorer. Please feel free to also add your rust code or a link to it.
|
||||
|
||||
#### Documenting findings
|
||||
|
||||
some enzyme errors, like `"attempting to call an indirect active function whose runtime value is inactive"`, have historically caused confusion. If you investigate such an issue, even if you don't find a complete solution, please consider documenting your findings. If the insights are general to enzyme and not specific to its rust usage, contributing them to the main [enzyme documentation](https://github.com/enzymead/www) is often the best first step. You can also mention your findings in the relevant enzyme github issue or propose updates to these docs if appropriate. This helps prevent others from starting from scratch.
|
||||
|
||||
With a clear reproducer and documentation, hopefully an enzyme developer will be able to fix your bug. Once that happens, the enzyme submodule inside the rust compiler will be updated, which should allow you to differentiate your rust code. Thanks for helping us to improve rust-ad.
|
||||
|
||||
# Minimize rust code
|
||||
|
||||
Beyond having a minimal llvm-ir reproducer, it is also helpful to have a minimal rust reproducer without dependencies. This allows us to add it as a test case to ci once we fix it, which avoids regressions for the future.
|
||||
|
||||
There are a few solutions to help you with minimizing the rust reproducer. This is probably the most simple automated approach: [cargo-minimize](https://github.com/nilstrieb/cargo-minimize).
|
||||
|
||||
Otherwise we have various alternatives, including [`treereduce`](https://github.com/langston-barrett/treereduce), [`halfempty`](https://github.com/googleprojectzero/halfempty), or [`picireny`](https://github.com/renatahodovan/picireny), potentially also [`creduce`](https://github.com/csmith-project/creduce).
|
||||
42
src/doc/rustc-dev-guide/src/autodiff/flags.md
Normal file
42
src/doc/rustc-dev-guide/src/autodiff/flags.md
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
# Supported `RUSTFLAGS`
|
||||
|
||||
To support you while debugging or profiling, we have added support for an experimental `-Z autodiff` rustc flag (which can be passed to cargo via `RUSTFLAGS`), which allow changing the behaviour of Enzyme, without recompiling rustc. We currently support the following values for `autodiff`.
|
||||
|
||||
### Debug Flags
|
||||
|
||||
```text
|
||||
PrintTA // Print TypeAnalysis information
|
||||
PrintAA // Print ActivityAnalysis information
|
||||
Print // Print differentiated functions while they are being generated and optimized
|
||||
PrintPerf // Print AD related Performance warnings
|
||||
PrintModBefore // Print the whole LLVM-IR module directly before running AD
|
||||
PrintModAfter // Print the whole LLVM-IR module after running AD, before optimizations
|
||||
PrintModFinal // Print the whole LLVM-IR module after running optimizations and AD
|
||||
LooseTypes // Risk incorrect derivatives instead of aborting when missing Type Info
|
||||
```
|
||||
|
||||
<div class="warning">
|
||||
`LooseTypes` is often helpful to get rid of Enzyme errors stating `Can not deduce type of <X>` and to be able to run some code. But please keep in mind that this flag absolutely has the chance to cause incorrect gradients. Even worse, the gradients might be correct for certain input values, but not for others. So please create issues about such bugs and only use this flag temporarily while you wait for your bug to be fixed.
|
||||
</div>
|
||||
|
||||
### Benchmark flags
|
||||
|
||||
For performance experiments and benchmarking we also support
|
||||
|
||||
```text
|
||||
NoPostopt // We won't optimize the LLVM-IR Module after AD
|
||||
RuntimeActivity // Enables the runtime activity feature from Enzyme
|
||||
Inline // Instructs Enzyme to maximize inlining as far as possible, beyond LLVM's default
|
||||
```
|
||||
|
||||
You can combine multiple `autodiff` values using a comma as separator:
|
||||
|
||||
```bash
|
||||
RUSTFLAGS="-Z autodiff=Enable,LooseTypes,PrintPerf" cargo +enzyme build
|
||||
```
|
||||
|
||||
Using `-Zautodiff=Enable` will allow using autodiff and update your normal rustc compilation pipeline:
|
||||
|
||||
1. Run your selected compilation pipeline. If you selected a release build, we will disable vectorization and loop unrolling.
|
||||
2. Differentiate your functions.
|
||||
3. Run your selected compilation pipeline again on the whole module. This time we do not disable vectorization or loop unrolling.
|
||||
86
src/doc/rustc-dev-guide/src/autodiff/installation.md
Normal file
86
src/doc/rustc-dev-guide/src/autodiff/installation.md
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
# Installation
|
||||
|
||||
In the near future, `std::autodiff` should become available in nightly builds for users. As a contribute however, you will still need to build rustc from source. Please be aware that the msvc target is not supported at the moment, all other tier 1 targets should work. Please open an issue if you encounter any problems on a supported tier 1 target, or if you succesfully build this project on a tier2/tier3 target.
|
||||
|
||||
## Build instructions
|
||||
|
||||
First you need to clone and configure the Rust repository:
|
||||
```bash
|
||||
git clone --depth=1 git@github.com:rust-lang/rust.git
|
||||
cd rust
|
||||
./configure --enable-llvm-link-shared --enable-llvm-plugins --enable-llvm-enzyme --release-channel=nightly --enable-llvm-assertions --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
|
||||
```
|
||||
|
||||
Afterwards you can build rustc using:
|
||||
```bash
|
||||
./x.py build --stage 1 library
|
||||
```
|
||||
|
||||
Afterwards rustc toolchain link will allow you to use it through cargo:
|
||||
```
|
||||
rustup toolchain link enzyme build/host/stage1
|
||||
rustup toolchain install nightly # enables -Z unstable-options
|
||||
```
|
||||
|
||||
You can then run our test cases:
|
||||
|
||||
```bash
|
||||
./x.py test --stage 1 library tests/ui/autodiff
|
||||
./x.py test --stage 1 library tests/codegen/autodiff
|
||||
./x.py test --stage 1 library tests/pretty/autodiff*
|
||||
```
|
||||
|
||||
Autodiff is still experimental, so if you want to use it in your own projects, you will need to add `lto="fat"` to your Cargo.toml
|
||||
and use `RUSTFLAGS="-Zautodiff=Enable" cargo +enzyme` instead of `cargo` or `cargo +nightly`.
|
||||
|
||||
## Compiler Explorer and dist builds
|
||||
|
||||
Our compiler explorer instance can be updated to a newer rustc in a similar way. First, prepare a docker instance.
|
||||
```bash
|
||||
docker run -it ubuntu:22.04
|
||||
export CC=clang CXX=clang++
|
||||
apt update
|
||||
apt install wget vim python3 git curl libssl-dev pkg-config lld ninja-build cmake clang build-essential
|
||||
```
|
||||
Then build rustc in a slightly altered way:
|
||||
```bash
|
||||
git clone --depth=1 https://github.com/EnzymeAD/rust.git
|
||||
cd rust
|
||||
./configure --enable-llvm-link-shared --enable-llvm-plugins --enable-llvm-enzyme --release-channel=nightly --enable-llvm-assertions --enable-clang --enable-lld --enable-option-checking --enable-ninja --disable-docs
|
||||
./x dist
|
||||
```
|
||||
We then copy the tarball to our host. The dockerid is the newest entry under `docker ps -a`.
|
||||
```bash
|
||||
docker cp <dockerid>:/rust/build/dist/rust-nightly-x86_64-unknown-linux-gnu.tar.gz rust-nightly-x86_64-unknown-linux-gnu.tar.gz
|
||||
```
|
||||
Afterwards we can create a new (pre-release) tag on the EnzymeAD/rust repository and make a PR against the EnzymeAD/enzyme-explorer repository to update the tag.
|
||||
Remember to ping `tgymnich` on the PR to run his update script.
|
||||
|
||||
|
||||
## Build instruction for Enzyme itself
|
||||
|
||||
Following the Rust build instruction above will build LLVMEnzyme, LLDEnzyme, and ClangEnzyme along with the Rust compiler.
|
||||
We recommend that approach, if you just want to use any of them and have no experience with cmake.
|
||||
However, if you prefer to just build Enzyme without Rust, then these instructions might help.
|
||||
|
||||
```bash
|
||||
git clone --depth=1 git@github.com:llvm/llvm-project.git
|
||||
cd llvm-project
|
||||
mkdir build
|
||||
cd build
|
||||
cmake -G Ninja ../llvm -DLLVM_TARGETS_TO_BUILD="host" -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_ENABLE_PROJECTS="clang;lld" -DLLVM_ENABLE_RUNTIMES="openmp" -DLLVM_ENABLE_PLUGINS=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=.
|
||||
ninja
|
||||
ninja install
|
||||
```
|
||||
This gives you a working LLVM build, now we can continue with building Enzyme.
|
||||
Leave the `llvm-project` folder, and execute the following commands:
|
||||
```bash
|
||||
git clone git@github.com:EnzymeAD/Enzyme.git
|
||||
cd Enzyme/enzyme
|
||||
mkdir build
|
||||
cd build
|
||||
cmake .. -G Ninja -DLLVM_DIR=<YourLocalPath>/llvm-project/build/lib/cmake/llvm/ -DLLVM_EXTERNAL_LIT=<YourLocalPath>/llvm-project/llvm/utils/lit/lit.py -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=YES -DBUILD_SHARED_LIBS=ON
|
||||
ninja
|
||||
```
|
||||
This will build Enzyme, and you can find it in `Enzyme/enzyme/build/lib/<LLD/Clang/LLVM>Enzyme.so`. (Endings might differ based on your OS).
|
||||
|
||||
27
src/doc/rustc-dev-guide/src/autodiff/internals.md
Normal file
27
src/doc/rustc-dev-guide/src/autodiff/internals.md
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
The `std::autodiff` module in Rust allows differentiable programming:
|
||||
|
||||
```rust
|
||||
#![feature(autodiff)]
|
||||
use std::autodiff::autodiff;
|
||||
|
||||
// f(x) = x * x, f'(x) = 2.0 * x
|
||||
// bar therefore returns (x * x, 2.0 * x)
|
||||
#[autodiff(bar, Reverse, Active, Active)]
|
||||
fn foo(x: f32) -> f32 { x * x }
|
||||
|
||||
fn main() {
|
||||
assert_eq!(bar(3.0, 1.0), (9.0, 6.0));
|
||||
assert_eq!(bar(4.0, 1.0), (16.0, 8.0));
|
||||
}
|
||||
```
|
||||
|
||||
The detailed documentation for the `std::autodiff` module is available at [std::autodiff](https://doc.rust-lang.org/std/autodiff/index.html).
|
||||
|
||||
Differentiable programing is used in various fields like numerical computing, [solid mechanics][ratel], [computational chemistry][molpipx], [fluid dynamics][waterlily] or for Neural Network training via Backpropagation, [ODE solver][diffsol], [differentiable rendering][libigl], [quantum computing][catalyst], and climate simulations.
|
||||
|
||||
[ratel]: https://gitlab.com/micromorph/ratel
|
||||
[molpipx]: https://arxiv.org/abs/2411.17011v
|
||||
[waterlily]: https://github.com/WaterLily-jl/WaterLily.jl
|
||||
[diffsol]: https://github.com/martinjrobins/diffsol
|
||||
[libigl]: https://github.com/alecjacobson/libigl-enzyme-example?tab=readme-ov-file#run
|
||||
[catalyst]: https://github.com/PennyLaneAI/catalyst
|
||||
27
src/doc/rustc-dev-guide/src/autodiff/limitations.md
Normal file
27
src/doc/rustc-dev-guide/src/autodiff/limitations.md
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
# Current limitations
|
||||
|
||||
## Safety and Soundness
|
||||
|
||||
Enzyme currently assumes that the user passes shadow arguments (`dx`, `dy`, ...) of appropriate size. Under Reverse Mode, we additionally assume that shadow arguments are mutable. In Reverse Mode we adjust the outermost pointer or reference to be mutable. Therefore `&f32` will receive the shadow type `&mut f32`. However, we do not check length for other types than slices (e.g. enums, Vec). We also do not enforce mutability of inner references, but will warn if we recognize them. We do intend to add additional checks over time.
|
||||
|
||||
## ABI adjustments
|
||||
|
||||
In some cases, a function parameter might get lowered in a way that we currently don't handle correctly, leading to a compile time type mismatch in the `rustc_codegen_llvm` backend. Here are some [examples](https://github.com/EnzymeAD/rust/issues/105).
|
||||
|
||||
## Compile Times
|
||||
|
||||
Enzyme will often achieve excellent runtime performance, but might increase your compile time by a large factor. For Rust, we already have made significant improvements and have a list of further improvements planed - please reach out if you have time to help here.
|
||||
|
||||
### Type Analysis
|
||||
|
||||
Most of the times, Type Analysis (TA) is the reason of large (>5x) compile time increases when using Enzyme. This poster explains why we need to run Type Analysis in the bottom left part: [Poster Link](https://c.wsmoses.com/posters/Enzyme-llvmdev.pdf).
|
||||
|
||||
We intend to increase the number of locations where we pass down Type information based on Rust types, which in turn will reduce the number of locations where Enzyme has to run Type Analysis, which will help compile times.
|
||||
|
||||
### Duplicated Optimizations
|
||||
|
||||
The key reason for Enzyme offering often excellent performance is that Enzyme differentiates already optimized LLVM-IR. However, we also (have to) run LLVM's optimization pipeline after differentiating, to make sure that the code which Enzyme generates is optimized properly. As a result you should have excellent runtime performance (please fill an issue if not), but at a compile time cost for running optimizations twice.
|
||||
|
||||
### Fat-LTO
|
||||
|
||||
The usage of `#[autodiff(...)]` currently requires compiling your project with Fat-LTO. We technically only need LTO if the function being differentiated calls functions in other compilation units. Therefore, other solutions are possible, but this is the most simple one to get started.
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
# Procedures for Breaking Changes
|
||||
# Procedures for breaking changes
|
||||
|
||||
<!-- toc -->
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,53 @@
|
|||
# `cfg(bootstrap)` in compiler dependencies
|
||||
|
||||
The rust compiler uses some external crates that can run into cyclic dependencies with the compiler itself: the compiler needs an updated crate to build, but the crate needs an updated compiler. This page describes how `#[cfg(bootstrap)]` can be used to break this cycle.
|
||||
|
||||
## Enabling `#[cfg(bootstrap)]`
|
||||
|
||||
Usually the use of `#[cfg(bootstrap)]` in an external crate causes a warning:
|
||||
|
||||
```
|
||||
warning: unexpected `cfg` condition name: `bootstrap`
|
||||
--> src/main.rs:1:7
|
||||
|
|
||||
1 | #[cfg(bootstrap)]
|
||||
| ^^^^^^^^^
|
||||
|
|
||||
= help: expected names are: `docsrs`, `feature`, and `test` and 31 more
|
||||
= help: consider using a Cargo feature instead
|
||||
= help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
|
||||
[lints.rust]
|
||||
unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bootstrap)'] }
|
||||
= help: or consider adding `println!("cargo::rustc-check-cfg=cfg(bootstrap)");` to the top of the `build.rs`
|
||||
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
|
||||
= note: `#[warn(unexpected_cfgs)]` on by default
|
||||
```
|
||||
|
||||
This warning can be silenced by adding these lines to the project's `Cargo.toml`:
|
||||
|
||||
```toml
|
||||
[lints.rust]
|
||||
unexpected_cfgs = { level = "warn", check-cfg = ['cfg(bootstrap)'] }
|
||||
```
|
||||
|
||||
Now `#[cfg(bootstrap)]` can be used in the crate just like it can be in the compiler: when the bootstrap compiler is used, code annotated with `#[cfg(bootstrap)]` is compiled, otherwise code annotated with `#[cfg(not(bootstrap))]` is compiled.
|
||||
|
||||
## The update dance
|
||||
|
||||
As a concrete example we'll use a change where the `#[naked]` attribute was made into an unsafe attribute, which caused a cyclic dependency with the `compiler-builtins` crate.
|
||||
|
||||
### Step 1: accept the new behavior in the compiler ([#139797](https://github.com/rust-lang/rust/pull/139797))
|
||||
|
||||
In this example it is possible to accept both the old and new behavior at the same time by disabling an error.
|
||||
|
||||
### Step 2: update the crate ([#821](https://github.com/rust-lang/compiler-builtins/pull/821))
|
||||
|
||||
Now in the crate, use `#[cfg(bootstrap)]` to use the old behavior, or `#[cfg(not(bootstrap))]` to use the new behavior.
|
||||
|
||||
### Step 3: update the crate version used by the compiler ([#139934](https://github.com/rust-lang/rust/pull/139934))
|
||||
|
||||
For `compiler-builtins` this meant a version bump, in other cases it may be a git submodule update.
|
||||
|
||||
### Step 4: remove the old behavior from the compiler ([#139753](https://github.com/rust-lang/rust/pull/139753))
|
||||
|
||||
The updated crate can now be used. In this example that meant that the old behavior could be removed.
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
# Suggested Workflows
|
||||
# Suggested workflows
|
||||
|
||||
The full bootstrapping process takes quite a while. Here are some suggestions to
|
||||
make your life easier.
|
||||
|
|
|
|||
|
|
@ -1,4 +1,3 @@
|
|||
|
||||
# Coherence
|
||||
|
||||
> NOTE: this is based on [notes by @lcnr](https://github.com/rust-lang/rust/pull/121848)
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Contribution Procedures
|
||||
# Contribution procedures
|
||||
|
||||
<!-- toc -->
|
||||
|
||||
|
|
@ -150,6 +150,20 @@ when contributing to Rust under [the git section](./git.md).
|
|||
[t-compiler]: https://rust-lang.zulipchat.com/#narrow/stream/131828-t-compiler
|
||||
[triagebot]: https://github.com/rust-lang/rust/blob/master/triagebot.toml
|
||||
|
||||
### Keeping your branch up-to-date
|
||||
|
||||
The CI in rust-lang/rust applies your patches directly against the current master,
|
||||
not against the commit your branch is based on. This can lead to unexpected failures
|
||||
if your branch is outdated, even when there are no explicit merge conflicts.
|
||||
|
||||
Before submitting or updating a PR, make sure to update your branch
|
||||
as mentioned [here](git.md#keeping-things-up-to-date) if it's significantly
|
||||
behind the master branch (e.g., more than 100 commits behind).
|
||||
This fetches the latest master branch and rebases your changes on top of it,
|
||||
ensuring your PR is tested against the latest code.
|
||||
|
||||
After rebasing, it's recommended to [run the relevant tests locally](tests/intro.md) to catch any issues before CI runs.
|
||||
|
||||
### r?
|
||||
|
||||
All pull requests are reviewed by another person. We have a bot,
|
||||
|
|
@ -346,7 +360,7 @@ function in the same way as other pull requests.
|
|||
[`src/doc`]: https://github.com/rust-lang/rust/tree/master/src/doc
|
||||
[std-root]: https://github.com/rust-lang/rust/blob/master/library/std/src/lib.rs#L1
|
||||
|
||||
To find documentation-related issues, sort by the [A-docs label].
|
||||
To find documentation-related issues, use the [A-docs label].
|
||||
|
||||
You can find documentation style guidelines in [RFC 1574].
|
||||
|
||||
|
|
@ -373,7 +387,7 @@ Just a few things to keep in mind:
|
|||
There is no strict limit on line lengths; let the sentence or part of the sentence flow to its proper end on the same line.
|
||||
|
||||
- When contributing text to the guide, please contextualize the information with some time period
|
||||
and/or a reason so that the reader knows how much to trust or mistrust the information.
|
||||
and/or a reason so that the reader knows how much to trust the information.
|
||||
Aim to provide a reasonable amount of context, possibly including but not limited to:
|
||||
|
||||
- A reason for why the data may be out of date other than "change",
|
||||
|
|
@ -387,28 +401,28 @@ Just a few things to keep in mind:
|
|||
- jan 2021
|
||||
- january 2021
|
||||
|
||||
There is a CI action (in `~/.github/workflows/date-check.yml`)
|
||||
that generates a monthly showing those that are over 6 months old
|
||||
There is a CI action (in `.github/workflows/date-check.yml`)
|
||||
that generates a monthly report showing those that are over 6 months old
|
||||
([example](https://github.com/rust-lang/rustc-dev-guide/issues/2052)).
|
||||
|
||||
For the action to pick the date,
|
||||
add a special annotation before specifying the date:
|
||||
|
||||
```md
|
||||
<!-- date-check --> Sep 2024
|
||||
<!-- date-check --> Apr 2025
|
||||
```
|
||||
|
||||
Example:
|
||||
|
||||
```md
|
||||
As of <!-- date-check --> Sep 2024, the foo did the bar.
|
||||
As of <!-- date-check --> Apr 2025, the foo did the bar.
|
||||
```
|
||||
|
||||
For cases where the date should not be part of the visible rendered output,
|
||||
use the following instead:
|
||||
|
||||
```md
|
||||
<!-- date-check: Sep 2024 -->
|
||||
<!-- date-check: Apr 2025 -->
|
||||
```
|
||||
|
||||
- A link to a relevant WG, tracking issue, `rustc` rustdoc page, or similar, that may provide
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
# Coding conventions
|
||||
|
||||
This file offers some tips on the coding conventions for rustc. This
|
||||
chapter covers [formatting](#formatting), [coding for correctness](#cc),
|
||||
[using crates from crates.io](#cio), and some tips on
|
||||
|
|
@ -5,7 +7,7 @@ chapter covers [formatting](#formatting), [coding for correctness](#cc),
|
|||
|
||||
<a id="formatting"></a>
|
||||
|
||||
# Formatting and the tidy script
|
||||
## Formatting and the tidy script
|
||||
|
||||
rustc is moving towards the [Rust standard coding style][fmt].
|
||||
|
||||
|
|
@ -20,44 +22,42 @@ Formatting is checked by the `tidy` script. It runs automatically when you do
|
|||
`./x test` and can be run in isolation with `./x fmt --check`.
|
||||
|
||||
If you want to use format-on-save in your editor, the pinned version of
|
||||
`rustfmt` is built under `build/<target>/stage0/bin/rustfmt`. You'll have to
|
||||
pass the <!-- date-check: nov 2022 --> `--edition=2021` argument yourself when calling
|
||||
`rustfmt` directly.
|
||||
`rustfmt` is built under `build/<target>/stage0/bin/rustfmt`.
|
||||
|
||||
[fmt]: https://github.com/rust-dev-tools/fmt-rfcs
|
||||
|
||||
[`rustfmt`]:https://github.com/rust-lang/rustfmt
|
||||
|
||||
## Formatting C++ code
|
||||
### Formatting C++ code
|
||||
|
||||
The compiler contains some C++ code for interfacing with parts of LLVM that
|
||||
don't have a stable C API.
|
||||
When modifying that code, use this command to format it:
|
||||
|
||||
```sh
|
||||
./x test tidy --extra-checks=cpp:fmt --bless
|
||||
```console
|
||||
./x test tidy --extra-checks cpp:fmt --bless
|
||||
```
|
||||
|
||||
This uses a pinned version of `clang-format`, to avoid relying on the local
|
||||
environment.
|
||||
|
||||
## Formatting and linting Python code
|
||||
### Formatting and linting Python code
|
||||
|
||||
The Rust repository contains quite a lot of Python code. We try to keep
|
||||
it both linted and formatted by the [ruff][ruff] tool.
|
||||
it both linted and formatted by the [ruff] tool.
|
||||
|
||||
When modifying Python code, use this command to format it:
|
||||
```sh
|
||||
./x test tidy --extra-checks=py:fmt --bless
|
||||
|
||||
```console
|
||||
./x test tidy --extra-checks py:fmt --bless
|
||||
```
|
||||
|
||||
and the following command to run lints:
|
||||
```sh
|
||||
./x test tidy --extra-checks=py:lint
|
||||
And, the following command to run lints:
|
||||
|
||||
```console
|
||||
./x test tidy --extra-checks py:lint
|
||||
```
|
||||
|
||||
This uses a pinned version of `ruff`, to avoid relying on the local
|
||||
environment.
|
||||
These use a pinned version of `ruff`, to avoid relying on the local environment.
|
||||
|
||||
[ruff]: https://github.com/astral-sh/ruff
|
||||
|
||||
|
|
@ -65,7 +65,7 @@ environment.
|
|||
|
||||
<!-- REUSE-IgnoreStart -->
|
||||
<!-- Prevent REUSE from interpreting the heading as a copyright notice -->
|
||||
## Copyright notice
|
||||
### Copyright notice
|
||||
<!-- REUSE-IgnoreEnd -->
|
||||
|
||||
In the past, files began with a copyright and license notice. Please **omit**
|
||||
|
|
@ -75,41 +75,42 @@ MIT/Apache-2.0).
|
|||
All of the copyright notices should be gone by now, but if you come across one
|
||||
in the rust-lang/rust repo, feel free to open a PR to remove it.
|
||||
|
||||
## Line length
|
||||
### Line length
|
||||
|
||||
Lines should be at most 100 characters. It's even better if you can
|
||||
keep things to 80.
|
||||
|
||||
**Ignoring the line length limit.** Sometimes – in particular for
|
||||
tests – it can be necessary to exempt yourself from this limit. In
|
||||
that case, you can add a comment towards the top of the file like so:
|
||||
Sometimes, and particularly for tests, it can be necessary to exempt yourself from this limit.
|
||||
In that case, you can add a comment towards the top of the file like so:
|
||||
|
||||
```rust
|
||||
// ignore-tidy-linelength
|
||||
```
|
||||
|
||||
## Tabs vs spaces
|
||||
### Tabs vs spaces
|
||||
|
||||
Prefer 4-space indent.
|
||||
Prefer 4-space indents.
|
||||
|
||||
<a id="cc"></a>
|
||||
|
||||
# Coding for correctness
|
||||
## Coding for correctness
|
||||
|
||||
Beyond formatting, there are a few other tips that are worth
|
||||
following.
|
||||
|
||||
## Prefer exhaustive matches
|
||||
### Prefer exhaustive matches
|
||||
|
||||
Using `_` in a match is convenient, but it means that when new
|
||||
variants are added to the enum, they may not get handled correctly.
|
||||
Ask yourself: if a new variant were added to this enum, what's the
|
||||
chance that it would want to use the `_` code, versus having some
|
||||
other treatment? Unless the answer is "low", then prefer an
|
||||
exhaustive match. (The same advice applies to `if let` and `while
|
||||
let`, which are effectively tests for a single variant.)
|
||||
exhaustive match.
|
||||
|
||||
## Use "TODO" comments for things you don't want to forget
|
||||
The same advice applies to `if let` and `while let`,
|
||||
which are effectively tests for a single variant.
|
||||
|
||||
### Use "TODO" comments for things you don't want to forget
|
||||
|
||||
As a useful tool to yourself, you can insert a `// TODO` comment
|
||||
for something that you want to get back to before you land your PR:
|
||||
|
|
@ -136,13 +137,13 @@ if foo {
|
|||
|
||||
<a id="cio"></a>
|
||||
|
||||
# Using crates from crates.io
|
||||
## Using crates from crates.io
|
||||
|
||||
See the [crates.io dependencies][crates] section.
|
||||
|
||||
<a id="er"></a>
|
||||
|
||||
# How to structure your PR
|
||||
## How to structure your PR
|
||||
|
||||
How you prepare the commits in your PR can make a big difference for the
|
||||
reviewer. Here are some tips.
|
||||
|
|
@ -172,7 +173,7 @@ require that every intermediate commit successfully builds – we only
|
|||
expect to be able to bisect at a PR level. However, if you *can* make
|
||||
individual commits build, that is always helpful.
|
||||
|
||||
# Naming conventions
|
||||
## Naming conventions
|
||||
|
||||
Apart from normal Rust style/naming conventions, there are also some specific
|
||||
to the compiler.
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# crates.io Dependencies
|
||||
# crates.io dependencies
|
||||
|
||||
The Rust compiler supports building with some dependencies from `crates.io`.
|
||||
Examples are `log` and `env_logger`.
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Errors and Lints
|
||||
# Errors and lints
|
||||
|
||||
<!-- toc -->
|
||||
|
||||
|
|
@ -772,7 +772,7 @@ store.register_renamed("single_use_lifetime", "single_use_lifetimes");
|
|||
[`store.register_removed`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/struct.LintStore.html#method.register_removed
|
||||
[`rustc_lint::register_builtins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_lint/fn.register_builtins.html
|
||||
|
||||
### Lint Groups
|
||||
### Lint groups
|
||||
|
||||
Lints can be turned on in groups. These groups are declared in the
|
||||
[`register_builtins`][rbuiltins] function in [`rustc_lint::lib`][builtin]. The
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Feature Gates
|
||||
# Feature gates
|
||||
|
||||
This chapter is intended to provide basic help for adding, removing, and
|
||||
modifying feature gates.
|
||||
|
|
|
|||
|
|
@ -144,7 +144,7 @@ that `n` must be some HIR expression, you can do
|
|||
Finally, you can find the parents of nodes, via
|
||||
calls like [`tcx.parent_hir_node(n)`][parent_hir_node].
|
||||
|
||||
[get_parent_item]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.parent_hir_node
|
||||
[parent_hir_node]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_middle/ty/struct.TyCtxt.html#method.parent_hir_node
|
||||
|
||||
|
||||
## HIR Bodies
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Debugging and Testing Dependencies
|
||||
# Debugging and testing dependencies
|
||||
|
||||
## Testing the dependency graph
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Memory Management in Rustc
|
||||
# Memory management in rustc
|
||||
|
||||
Generally rustc tries to be pretty careful how it manages memory.
|
||||
The compiler allocates _a lot_ of data structures throughout compilation,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Panicking in rust
|
||||
# Panicking in Rust
|
||||
|
||||
<!-- toc -->
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Parallel Compilation
|
||||
# Parallel compilation
|
||||
|
||||
<div class="warning">
|
||||
As of <!-- date-check --> November 2024,
|
||||
|
|
@ -28,7 +28,7 @@ The following sections are kept for now but are quite outdated.
|
|||
|
||||
[codegen]: backend/codegen.md
|
||||
|
||||
## Code Generation
|
||||
## Code generation
|
||||
|
||||
During monomorphization the compiler splits up all the code to
|
||||
be generated into smaller chunks called _codegen units_. These are then generated by
|
||||
|
|
@ -38,7 +38,7 @@ occurs in the [`rustc_codegen_ssa::base`] module.
|
|||
|
||||
[`rustc_codegen_ssa::base`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_codegen_ssa/base/index.html
|
||||
|
||||
## Data Structures
|
||||
## Data structures
|
||||
|
||||
The underlying thread-safe data-structures used in the parallel compiler
|
||||
can be found in the [`rustc_data_structures::sync`] module. These data structures
|
||||
|
|
@ -83,7 +83,7 @@ can be accessed directly through `Deref::deref`.
|
|||
[`rustc_data_structures::sync::worker_local`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/sync/worker_local/index.html
|
||||
[`WorkerLocal`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_data_structures/sync/worker_local/struct.WorkerLocal.html
|
||||
|
||||
## Parallel Iterator
|
||||
## Parallel iterator
|
||||
|
||||
The parallel iterators provided by the [`rayon`] crate are easy ways to
|
||||
implement parallelism. In the current implementation of the parallel compiler
|
||||
|
|
@ -124,7 +124,7 @@ the parallel iterator function has been used are as follows:
|
|||
|
||||
There are still many loops that have the potential to use parallel iterators.
|
||||
|
||||
## Query System
|
||||
## Query system
|
||||
|
||||
The query model has some properties that make it actually feasible to evaluate
|
||||
multiple queries in parallel without too much effort:
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Incremental Compilation In Detail
|
||||
# Incremental Compilation in detail
|
||||
|
||||
<!-- toc -->
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# The Query Evaluation Model in Detail
|
||||
# The Query Evaluation Model in detail
|
||||
|
||||
<!-- toc -->
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Serialization in Rustc
|
||||
# Serialization in rustc
|
||||
|
||||
rustc has to [serialize] and deserialize various data during compilation.
|
||||
Specifically:
|
||||
|
|
|
|||
|
|
@ -83,7 +83,7 @@ with your hand-written one, it will not share a [Symbol][Symbol]. This
|
|||
technique prevents name collision during code generation and is the foundation
|
||||
of Rust's [`macro`] hygiene.
|
||||
|
||||
## Step 2: Harness Generation
|
||||
## Step 2: Harness generation
|
||||
|
||||
Now that our tests are accessible from the root of our crate, we need to do
|
||||
something with them using [`rustc_ast`][ast] generates a module like so:
|
||||
|
|
@ -106,7 +106,7 @@ called [`test`][test] that is part of Rust core, that implements all of the
|
|||
runtime for testing. [`test`][test]'s interface is unstable, so the only stable way
|
||||
to interact with it is through the `#[test]` macro.
|
||||
|
||||
## Step 3: Test Object Generation
|
||||
## Step 3: Test object generation
|
||||
|
||||
If you've written tests in Rust before, you may be familiar with some of the
|
||||
optional attributes available on test functions. For example, a test can be
|
||||
|
|
|
|||
|
|
@ -15,9 +15,11 @@ CI. See the [Crater chapter](crater.md) for more details.
|
|||
|
||||
`cargotest` is a small tool which runs `cargo test` on a few sample projects
|
||||
(such as `servo`, `ripgrep`, `tokei`, etc.). This runs as part of CI and ensures
|
||||
there aren't any significant regressions.
|
||||
there aren't any significant regressions:
|
||||
|
||||
> Example: `./x test src/tools/cargotest`
|
||||
```console
|
||||
./x test src/tools/cargotest
|
||||
```
|
||||
|
||||
### Large OSS Project builders
|
||||
|
||||
|
|
|
|||
|
|
@ -596,4 +596,27 @@ with "user-facing" Rust alone. Indeed, one could say that this slightly abuses
|
|||
the term "UI" (*user* interface) and turns such UI tests from black-box tests
|
||||
into white-box ones. Use them carefully and sparingly.
|
||||
|
||||
[compiler debugging]: ../compiler-debugging.md#rustc_test-attributes
|
||||
[compiler debugging]: ../compiler-debugging.md#rustc_-test-attributes
|
||||
|
||||
## UI test mode preset lint levels
|
||||
|
||||
By default, test suites under UI test mode (`tests/ui`, `tests/ui-fulldeps`,
|
||||
but not `tests/rustdoc-ui`) will specify
|
||||
|
||||
- `-A unused`
|
||||
- `-A internal_features`
|
||||
|
||||
If:
|
||||
|
||||
- The ui test's pass mode is below `run` (i.e. check or build).
|
||||
- No compare modes are specified.
|
||||
|
||||
Since they can be very noisy in ui tests.
|
||||
|
||||
You can override them with `compile-flags` lint level flags or
|
||||
in-source lint level attributes as required.
|
||||
|
||||
Note that the `rustfix` version will *not* have `-A unused` passed,
|
||||
meaning that you may have to `#[allow(unused)]` to suppress `unused`
|
||||
lints on the rustfix'd file (because we might be testing rustfix
|
||||
on `unused` lints themselves).
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Lexing and Parsing
|
||||
# Lexing and parsing
|
||||
|
||||
The very first thing the compiler does is take the program (in UTF-8 Unicode text)
|
||||
and turn it into a data format the compiler can work with more conveniently than strings.
|
||||
|
|
@ -59,7 +59,7 @@ Note that while parsing, we may encounter macro definitions or invocations.
|
|||
We set these aside to be expanded (see [Macro Expansion](./macro-expansion.md)).
|
||||
Expansion itself may require parsing the output of a macro, which may reveal more macros to be expanded, and so on.
|
||||
|
||||
## More on Lexical Analysis
|
||||
## More on lexical analysis
|
||||
|
||||
Code for lexical analysis is split between two crates:
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
# Unsafety Checking
|
||||
# Unsafety checking
|
||||
|
||||
Certain expressions in Rust can violate memory safety and as such need to be
|
||||
inside an `unsafe` block or function. The compiler will also warn if an unsafe
|
||||
|
|
|
|||
|
|
@ -221,7 +221,7 @@ There are a couple of things that may happen for some PRs during the review proc
|
|||
some merge conflicts with other PRs that happen to get merged first. You
|
||||
should fix these merge conflicts using the normal git procedures.
|
||||
|
||||
[crater]: ./tests/intro.html#crater
|
||||
[crater]: ./tests/crater.html
|
||||
|
||||
If you are not doing a new feature or something like that (e.g. if you are
|
||||
fixing a bug), then that's it! Thanks for your contribution :)
|
||||
|
|
|
|||
|
|
@ -7,5 +7,9 @@ allow-unauthenticated = [
|
|||
"blocked",
|
||||
]
|
||||
|
||||
[no-mentions]
|
||||
|
||||
[canonicalize-issue-links]
|
||||
|
||||
# Automatically close and reopen PRs made by bots to run CI on them
|
||||
[bot-pull-requests]
|
||||
|
|
|
|||
|
|
@ -42,8 +42,7 @@ understood within a given context.
|
|||
|
||||
This section documents the exploit mitigations applicable to the Rust compiler
|
||||
when building programs for the Linux operating system on the AMD64 architecture
|
||||
and equivalent.<sup id="fnref:1" role="doc-noteref"><a href="#fn:1"
|
||||
class="footnote">1</a></sup> All examples in this section were built using
|
||||
and equivalent.[^all-targets] All examples in this section were built using
|
||||
nightly builds of the Rust compiler on Debian testing.
|
||||
|
||||
The Rust Programming Language currently has no specification. The Rust compiler
|
||||
|
|
@ -67,11 +66,8 @@ equivalent.
|
|||
| Forward-edge control flow protection | Yes | Nightly |
|
||||
| Backward-edge control flow protection (e.g., shadow and safe stack) | Yes | Nightly |
|
||||
|
||||
<small id="fn:1">1\. See
|
||||
<https://github.com/rust-lang/rust/tree/master/compiler/rustc_target/src/spec>
|
||||
for a list of targets and their default options. <a href="#fnref:1"
|
||||
class="reversefootnote" role="doc-backlink">↩</a></small>
|
||||
|
||||
[^all-targets]: See <https://github.com/rust-lang/rust/tree/master/compiler/rustc_target/src/spec>
|
||||
for a list of targets and their default options.
|
||||
|
||||
### Position-independent executable
|
||||
|
||||
|
|
@ -141,18 +137,15 @@ Integer overflow checks are enabled when debug assertions are enabled (see Fig.
|
|||
3), and disabled when debug assertions are disabled (see Fig. 4). To enable
|
||||
integer overflow checks independently, use the option to control integer
|
||||
overflow checks, scoped attributes, or explicit checking methods such as
|
||||
`checked_add`<sup id="fnref:2" role="doc-noteref"><a href="#fn:2"
|
||||
class="footnote">2</a></sup>.
|
||||
`checked_add`[^checked-methods].
|
||||
|
||||
It is recommended that explicit wrapping methods such as `wrapping_add` be used
|
||||
when wrapping semantics are intended, and that explicit checking and wrapping
|
||||
methods always be used when using Unsafe Rust.
|
||||
|
||||
<small id="fn:2">2\. See [the `u32` docs](../std/primitive.u32.html) for more
|
||||
information on the checked, overflowing, saturating, and wrapping methods
|
||||
(using u32 as an example). <a href="#fnref:2" class="reversefootnote"
|
||||
role="doc-backlink">↩</a></small>
|
||||
|
||||
[^checked-methods]: See [the `u32` docs](../std/primitive.u32.html) for more
|
||||
information on the checked, overflowing, saturating, and wrapping methods
|
||||
(using u32 as an example).
|
||||
|
||||
### Non-executable memory regions
|
||||
|
||||
|
|
@ -180,17 +173,14 @@ binary.
|
|||
|
||||
The presence of an element of type `PT_GNU_STACK` in the program header table
|
||||
with the `PF_X` (i.e., executable) flag unset indicates non-executable memory
|
||||
regions<sup id="fnref:3" role="doc-noteref"><a href="#fn:3"
|
||||
class="footnote">3</a></sup> are enabled for a given binary (see Fig. 5).
|
||||
regions[^other-regions] are enabled for a given binary (see Fig. 5).
|
||||
Conversely, the presence of an element of type `PT_GNU_STACK` in the program
|
||||
header table with the `PF_X` flag set or the absence of an element of type
|
||||
`PT_GNU_STACK` in the program header table indicates non-executable memory
|
||||
regions are not enabled for a given binary.
|
||||
|
||||
<small id="fn:3">3\. See the Appendix section for more information on why it
|
||||
affects other memory regions besides the stack. <a href="#fnref:3"
|
||||
class="reversefootnote" role="doc-backlink">↩</a></small>
|
||||
|
||||
[^other-regions]: See the [Appendix section](#appendix) for more information
|
||||
on why it affects other memory regions besides the stack.
|
||||
|
||||
### Stack clashing protection
|
||||
|
||||
|
|
@ -270,8 +260,7 @@ $ readelf -d target/release/hello-rust | grep BIND_NOW
|
|||
Fig. 10. Checking if immediate binding is enabled for a given binary.
|
||||
|
||||
The presence of an element with the `DT_BIND_NOW` tag and the `DF_BIND_NOW`
|
||||
flag<sup id="fnref:4" role="doc-noteref"><a href="#fn:4"
|
||||
class="footnote">4</a></sup> in the dynamic section indicates immediate binding
|
||||
flag[^bind-now] in the dynamic section indicates immediate binding
|
||||
is enabled for a given binary (see Fig. 10). Conversely, the absence of an
|
||||
element with the `DT_BIND_NOW` tag and the `DF_BIND_NOW` flag in the dynamic
|
||||
section indicates immediate binding is not enabled for a given binary.
|
||||
|
|
@ -281,9 +270,7 @@ table and of an element with the `DT_BIND_NOW` tag and the `DF_BIND_NOW` flag
|
|||
in the dynamic section indicates full RELRO is enabled for a given binary (see
|
||||
Figs. 9–10).
|
||||
|
||||
<small id="fn:4">4\. And the `DF_1_NOW` flag for some link editors. <a
|
||||
href="#fnref:4" class="reversefootnote" role="doc-backlink">↩</a></small>
|
||||
|
||||
[^bind-now]: And the `DF_1_NOW` flag for some link editors.
|
||||
|
||||
### Heap corruption protection
|
||||
|
||||
|
|
@ -303,8 +290,7 @@ Rust’s default allocator has historically been
|
|||
[jemalloc](http://jemalloc.net/), and it has long been the cause of issues and
|
||||
the subject of much discussion[32]–[38]. Consequently, it has been removed as
|
||||
the default allocator in favor of the operating system’s standard C library
|
||||
default allocator<sup id="fnref:5" role="doc-noteref"><a href="#fn:5"
|
||||
class="footnote">5</a></sup> since version 1.32.0 (2019-01-17)[39].
|
||||
default allocator[^linx-allocator] since version 1.32.0 (2019-01-17)[39].
|
||||
|
||||
```rust,no_run
|
||||
fn main() {
|
||||
|
|
@ -343,11 +329,9 @@ Fig. 13. Build and execution of hello-rust-heap with debug assertions disabled
|
|||
Heap corruption checks are performed when using the default allocator (i.e.,
|
||||
the GNU Allocator) (see Figs. 12–13).
|
||||
|
||||
<small id="fn:5">5\. Linux's standard C library default allocator is the GNU
|
||||
Allocator, which is derived from ptmalloc (pthreads malloc) by Wolfram Gloger,
|
||||
which in turn is derived from dlmalloc (Doug Lea malloc) by Doug Lea. <a
|
||||
href="#fnref:5" class="reversefootnote" role="doc-backlink">↩</a></small>
|
||||
|
||||
[^linx-allocator]: Linux's standard C library default allocator is the GNU
|
||||
Allocator, which is derived from ptmalloc (pthreads malloc) by Wolfram Gloger,
|
||||
which in turn is derived from dlmalloc (Doug Lea malloc) by Doug Lea.
|
||||
|
||||
### Stack smashing protection
|
||||
|
||||
|
|
@ -385,8 +369,7 @@ commercially available [grsecurity/PaX Reuse Attack Protector
|
|||
(RAP)](https://grsecurity.net/rap_faq).
|
||||
|
||||
The Rust compiler supports forward-edge control flow protection on nightly
|
||||
builds[41]-[42] <sup id="fnref:6" role="doc-noteref"><a href="#fn:6"
|
||||
class="footnote">6</a></sup>.
|
||||
builds[41]-[42] [^win-cfg].
|
||||
|
||||
```text
|
||||
$ readelf -s -W target/release/hello-rust | grep "\.cfi"
|
||||
|
|
@ -401,10 +384,8 @@ of symbols suffixed with ".cfi" or the `__cfi_init` symbol (and references to
|
|||
`__cfi_check`) indicates that LLVM CFI is not enabled for a given binary (see
|
||||
Fig. 15).
|
||||
|
||||
<small id="fn:6">6\. It also supports Control Flow Guard (CFG) on Windows (see
|
||||
<https://github.com/rust-lang/rust/issues/68793>). <a href="#fnref:6"
|
||||
class="reversefootnote" role="doc-backlink">↩</a></small>
|
||||
|
||||
[^win-cfg]: It also supports Control Flow Guard (CFG) on Windows (see
|
||||
<https://github.com/rust-lang/rust/issues/68793>).
|
||||
|
||||
### Backward-edge control flow protection
|
||||
|
||||
|
|
@ -431,8 +412,7 @@ Newer processors provide hardware assistance for backward-edge control flow
|
|||
protection, such as ARM Pointer Authentication, and Intel Shadow Stack as part
|
||||
of Intel CET.
|
||||
|
||||
The Rust compiler supports shadow stack for the AArch64 architecture<sup
|
||||
id="fnref:7" role="doc-noteref"><a href="#fn:7" class="footnote">7</a></sup>on
|
||||
The Rust compiler supports shadow stack for the AArch64 architecture[^amd64-shadow] on
|
||||
nightly builds[43]-[44], and also supports safe stack on nightly
|
||||
builds[45]-[46].
|
||||
|
||||
|
|
@ -447,9 +427,8 @@ enabled for a given binary. Conversely, the absence of the `__safestack_init`
|
|||
symbol indicates that LLVM SafeStack is not enabled for a given binary (see
|
||||
Fig. 16).
|
||||
|
||||
<small id="fn:7">7\. The shadow stack implementation for the AMD64 architecture
|
||||
and equivalent in LLVM was removed due to performance and security issues. <a
|
||||
href="#fnref:7" class="reversefootnote" role="doc-backlink">↩</a></small>
|
||||
[^amd64-shadow]: The shadow stack implementation for the AMD64 architecture
|
||||
and equivalent in LLVM was removed due to performance and security issues.
|
||||
|
||||
|
||||
## Appendix
|
||||
|
|
|
|||
|
|
@ -1382,6 +1382,11 @@ pub(crate) fn bool_to_simd_element(b: bool, size: Size) -> Scalar {
|
|||
}
|
||||
|
||||
pub(crate) fn simd_element_to_bool(elem: ImmTy<'_>) -> InterpResult<'_, bool> {
|
||||
assert!(
|
||||
matches!(elem.layout.ty.kind(), ty::Int(_) | ty::Uint(_)),
|
||||
"SIMD mask element type must be an integer, but this is `{}`",
|
||||
elem.layout.ty
|
||||
);
|
||||
let val = elem.to_scalar().to_int(elem.layout.size)?;
|
||||
interp_ok(match val {
|
||||
0 => false,
|
||||
|
|
|
|||
|
|
@ -29,6 +29,19 @@ pub unsafe fn gather_f32x2(
|
|||
simd_gather(values, pointers, mask)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @gather_f32x2_unsigned
|
||||
#[no_mangle]
|
||||
pub unsafe fn gather_f32x2_unsigned(
|
||||
pointers: Vec2<*const f32>,
|
||||
mask: Vec2<u32>,
|
||||
values: Vec2<f32>,
|
||||
) -> Vec2<f32> {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
|
||||
// CHECK: call <2 x float> @llvm.masked.gather.v2f32.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x float> {{.*}})
|
||||
simd_gather(values, pointers, mask)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @gather_pf32x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn gather_pf32x2(
|
||||
|
|
|
|||
|
|
@ -23,6 +23,19 @@ pub unsafe fn load_f32x2(mask: Vec2<i32>, pointer: *const f32, values: Vec2<f32>
|
|||
simd_masked_load(mask, pointer, values)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @load_f32x2_unsigned
|
||||
#[no_mangle]
|
||||
pub unsafe fn load_f32x2_unsigned(
|
||||
mask: Vec2<u32>,
|
||||
pointer: *const f32,
|
||||
values: Vec2<f32>,
|
||||
) -> Vec2<f32> {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
|
||||
// CHECK: call <2 x float> @llvm.masked.load.v2f32.p0(ptr {{.*}}, i32 4, <2 x i1> [[B]], <2 x float> {{.*}})
|
||||
simd_masked_load(mask, pointer, values)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @load_pf32x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn load_pf32x4(
|
||||
|
|
|
|||
|
|
@ -23,6 +23,15 @@ pub unsafe fn store_f32x2(mask: Vec2<i32>, pointer: *mut f32, values: Vec2<f32>)
|
|||
simd_masked_store(mask, pointer, values)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @store_f32x2_unsigned
|
||||
#[no_mangle]
|
||||
pub unsafe fn store_f32x2_unsigned(mask: Vec2<u32>, pointer: *mut f32, values: Vec2<f32>) {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
|
||||
// CHECK: call void @llvm.masked.store.v2f32.p0(<2 x float> {{.*}}, ptr {{.*}}, i32 4, <2 x i1> [[B]])
|
||||
simd_masked_store(mask, pointer, values)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @store_pf32x4
|
||||
#[no_mangle]
|
||||
pub unsafe fn store_pf32x4(mask: Vec4<i32>, pointer: *mut *const f32, values: Vec4<*const f32>) {
|
||||
|
|
|
|||
|
|
@ -25,6 +25,15 @@ pub unsafe fn scatter_f32x2(pointers: Vec2<*mut f32>, mask: Vec2<i32>, values: V
|
|||
simd_scatter(values, pointers, mask)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @scatter_f32x2_unsigned
|
||||
#[no_mangle]
|
||||
pub unsafe fn scatter_f32x2_unsigned(pointers: Vec2<*mut f32>, mask: Vec2<u32>, values: Vec2<f32>) {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
|
||||
// CHECK: call void @llvm.masked.scatter.v2f32.v2p0(<2 x float> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
|
||||
simd_scatter(values, pointers, mask)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @scatter_pf32x2
|
||||
#[no_mangle]
|
||||
pub unsafe fn scatter_pf32x2(
|
||||
|
|
|
|||
|
|
@ -22,6 +22,10 @@ pub struct b8x4(pub [i8; 4]);
|
|||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
pub struct i32x4([i32; 4]);
|
||||
|
||||
#[repr(simd)]
|
||||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
pub struct u32x4([u32; 4]);
|
||||
|
||||
// CHECK-LABEL: @select_m8
|
||||
#[no_mangle]
|
||||
pub unsafe fn select_m8(m: b8x4, a: f32x4, b: f32x4) -> f32x4 {
|
||||
|
|
@ -40,6 +44,15 @@ pub unsafe fn select_m32(m: i32x4, a: f32x4, b: f32x4) -> f32x4 {
|
|||
simd_select(m, a, b)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @select_m32_unsigned
|
||||
#[no_mangle]
|
||||
pub unsafe fn select_m32_unsigned(m: u32x4, a: f32x4, b: f32x4) -> f32x4 {
|
||||
// CHECK: [[A:%[0-9]+]] = lshr <4 x i32> %{{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
|
||||
// CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
|
||||
// CHECK: select <4 x i1> [[B]]
|
||||
simd_select(m, a, b)
|
||||
}
|
||||
|
||||
// CHECK-LABEL: @select_bitmask
|
||||
#[no_mangle]
|
||||
pub unsafe fn select_bitmask(m: i8, a: f32x8, b: f32x8) -> f32x8 {
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@ fn main() {
|
|||
let s_strided = x4([0_f32, 2., -3., 6.]);
|
||||
|
||||
let mask = x4([-1_i32, -1, 0, -1]);
|
||||
let umask = x4([0u16; 4]);
|
||||
let fmask = x4([0_f32; 4]);
|
||||
|
||||
let pointer = x.as_mut_ptr();
|
||||
|
|
@ -31,11 +30,8 @@ fn main() {
|
|||
simd_gather(default, mask, mask);
|
||||
//~^ ERROR expected element type `i32` of second argument `x4<i32>` to be a pointer to the element type `f32`
|
||||
|
||||
simd_gather(default, pointers, umask);
|
||||
//~^ ERROR expected element type `u16` of third argument `x4<u16>` to be a signed integer type
|
||||
|
||||
simd_gather(default, pointers, fmask);
|
||||
//~^ ERROR expected element type `f32` of third argument `x4<f32>` to be a signed integer type
|
||||
//~^ ERROR expected mask element type to be an integer, found `f32`
|
||||
}
|
||||
|
||||
unsafe {
|
||||
|
|
@ -43,10 +39,7 @@ fn main() {
|
|||
simd_scatter(values, mask, mask);
|
||||
//~^ ERROR expected element type `i32` of second argument `x4<i32>` to be a pointer to the element type `f32` of the first argument `x4<f32>`, found `i32` != `*mut f32`
|
||||
|
||||
simd_scatter(values, pointers, umask);
|
||||
//~^ ERROR expected element type `u16` of third argument `x4<u16>` to be a signed integer type
|
||||
|
||||
simd_scatter(values, pointers, fmask);
|
||||
//~^ ERROR expected element type `f32` of third argument `x4<f32>` to be a signed integer type
|
||||
//~^ ERROR expected mask element type to be an integer, found `f32`
|
||||
}
|
||||
}
|
||||
|
|
@ -1,39 +1,27 @@
|
|||
error[E0511]: invalid monomorphization of `simd_gather` intrinsic: expected element type `i32` of second argument `x4<i32>` to be a pointer to the element type `f32` of the first argument `x4<f32>`, found `i32` != `*_ f32`
|
||||
--> $DIR/generic-gather.rs:31:9
|
||||
--> $DIR/generic-gather-scatter.rs:30:9
|
||||
|
|
||||
LL | simd_gather(default, mask, mask);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_gather` intrinsic: expected element type `u16` of third argument `x4<u16>` to be a signed integer type
|
||||
--> $DIR/generic-gather.rs:34:9
|
||||
|
|
||||
LL | simd_gather(default, pointers, umask);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_gather` intrinsic: expected element type `f32` of third argument `x4<f32>` to be a signed integer type
|
||||
--> $DIR/generic-gather.rs:37:9
|
||||
error[E0511]: invalid monomorphization of `simd_gather` intrinsic: expected mask element type to be an integer, found `f32`
|
||||
--> $DIR/generic-gather-scatter.rs:33:9
|
||||
|
|
||||
LL | simd_gather(default, pointers, fmask);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_scatter` intrinsic: expected element type `i32` of second argument `x4<i32>` to be a pointer to the element type `f32` of the first argument `x4<f32>`, found `i32` != `*mut f32`
|
||||
--> $DIR/generic-gather.rs:43:9
|
||||
--> $DIR/generic-gather-scatter.rs:39:9
|
||||
|
|
||||
LL | simd_scatter(values, mask, mask);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_scatter` intrinsic: expected element type `u16` of third argument `x4<u16>` to be a signed integer type
|
||||
--> $DIR/generic-gather.rs:46:9
|
||||
|
|
||||
LL | simd_scatter(values, pointers, umask);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_scatter` intrinsic: expected element type `f32` of third argument `x4<f32>` to be a signed integer type
|
||||
--> $DIR/generic-gather.rs:49:9
|
||||
error[E0511]: invalid monomorphization of `simd_scatter` intrinsic: expected mask element type to be an integer, found `f32`
|
||||
--> $DIR/generic-gather-scatter.rs:42:9
|
||||
|
|
||||
LL | simd_scatter(values, pointers, fmask);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: aborting due to 6 previous errors
|
||||
error: aborting due to 4 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0511`.
|
||||
|
|
@ -36,11 +36,8 @@ fn main() {
|
|||
simd_select(m8, x, x);
|
||||
//~^ ERROR mismatched lengths: mask length `8` != other vector length `4`
|
||||
|
||||
simd_select(x, x, x);
|
||||
//~^ ERROR mask element type is `u32`, expected a signed integer type
|
||||
|
||||
simd_select(z, z, z);
|
||||
//~^ ERROR mask element type is `f32`, expected a signed integer type
|
||||
//~^ ERROR expected mask element type to be an integer, found `f32`
|
||||
|
||||
simd_select(m4, 0u32, 1u32);
|
||||
//~^ ERROR found non-SIMD `u32`
|
||||
|
|
|
|||
|
|
@ -4,52 +4,42 @@ error[E0511]: invalid monomorphization of `simd_select` intrinsic: mismatched le
|
|||
LL | simd_select(m8, x, x);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select` intrinsic: found mask element type is `u32`, expected a signed integer type
|
||||
error[E0511]: invalid monomorphization of `simd_select` intrinsic: expected mask element type to be an integer, found `f32`
|
||||
--> $DIR/generic-select.rs:39:9
|
||||
|
|
||||
LL | simd_select(x, x, x);
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: the mask may be widened, which only has the correct behavior for signed integers
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select` intrinsic: found mask element type is `f32`, expected a signed integer type
|
||||
--> $DIR/generic-select.rs:42:9
|
||||
|
|
||||
LL | simd_select(z, z, z);
|
||||
| ^^^^^^^^^^^^^^^^^^^^
|
||||
|
|
||||
= note: the mask may be widened, which only has the correct behavior for signed integers
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select` intrinsic: expected SIMD argument type, found non-SIMD `u32`
|
||||
--> $DIR/generic-select.rs:45:9
|
||||
--> $DIR/generic-select.rs:42:9
|
||||
|
|
||||
LL | simd_select(m4, 0u32, 1u32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: invalid bitmask `u16`, expected `u8` or `[u8; 1]`
|
||||
--> $DIR/generic-select.rs:48:9
|
||||
--> $DIR/generic-select.rs:45:9
|
||||
|
|
||||
LL | simd_select_bitmask(0u16, x, x);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: expected SIMD argument type, found non-SIMD `u32`
|
||||
--> $DIR/generic-select.rs:51:9
|
||||
--> $DIR/generic-select.rs:48:9
|
||||
|
|
||||
LL | simd_select_bitmask(0u8, 1u32, 2u32);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: invalid bitmask `f32`, expected `u8` or `[u8; 1]`
|
||||
--> $DIR/generic-select.rs:54:9
|
||||
--> $DIR/generic-select.rs:51:9
|
||||
|
|
||||
LL | simd_select_bitmask(0.0f32, x, x);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: invalid bitmask `&str`, expected `u8` or `[u8; 1]`
|
||||
--> $DIR/generic-select.rs:57:9
|
||||
--> $DIR/generic-select.rs:54:9
|
||||
|
|
||||
LL | simd_select_bitmask("x", x, x);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: aborting due to 8 previous errors
|
||||
error: aborting due to 7 previous errors
|
||||
|
||||
For more information about this error, try `rustc --explain E0511`.
|
||||
|
|
|
|||
|
|
@ -21,8 +21,8 @@ fn main() {
|
|||
simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u32, 4>([9; 4]));
|
||||
//~^ ERROR expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*_ u32`
|
||||
|
||||
simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
|
||||
//~^ ERROR expected element type `u8` of third argument `Simd<u8, 4>` to be a signed integer type
|
||||
simd_masked_load(Simd::<f32, 4>([1.0, 0.0, 1.0, 1.0]), arr.as_ptr(), default);
|
||||
//~^ ERROR expected mask element type to be an integer, found `f32`
|
||||
|
||||
simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u32; 4]));
|
||||
//~^ ERROR expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*mut u32`
|
||||
|
|
@ -33,7 +33,7 @@ fn main() {
|
|||
simd_masked_store(Simd([-1i8; 4]), arr.as_mut_ptr(), Simd([5u8; 2]));
|
||||
//~^ ERROR expected third argument with length 4 (same as input type `Simd<i8, 4>`), found `Simd<u8, 2>` with length 2
|
||||
|
||||
simd_masked_store(Simd([1u32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
|
||||
//~^ ERROR expected element type `u8` of third argument `Simd<u32, 4>` to be a signed integer type
|
||||
simd_masked_store(Simd([1f32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
|
||||
//~^ ERROR expected mask element type to be an integer, found `f32`
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,11 +16,11 @@ error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected
|
|||
LL | simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u32, 4>([9; 4]));
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected element type `u8` of third argument `Simd<u8, 4>` to be a signed integer type
|
||||
error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected mask element type to be an integer, found `f32`
|
||||
--> $DIR/masked-load-store-build-fail.rs:24:9
|
||||
|
|
||||
LL | simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
LL | simd_masked_load(Simd::<f32, 4>([1.0, 0.0, 1.0, 1.0]), arr.as_ptr(), default);
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*mut u32`
|
||||
--> $DIR/masked-load-store-build-fail.rs:27:9
|
||||
|
|
@ -40,10 +40,10 @@ error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expecte
|
|||
LL | simd_masked_store(Simd([-1i8; 4]), arr.as_mut_ptr(), Simd([5u8; 2]));
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u8` of third argument `Simd<u32, 4>` to be a signed integer type
|
||||
error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected mask element type to be an integer, found `f32`
|
||||
--> $DIR/masked-load-store-build-fail.rs:36:9
|
||||
|
|
||||
LL | simd_masked_store(Simd([1u32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
|
||||
LL | simd_masked_store(Simd([1f32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
|
||||
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
||||
|
||||
error: aborting due to 8 previous errors
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue