Auto merge of rust-lang#119459 - cjgillot:inline-mir-utils, r=compiler-errors

bors · bors · commit d62f05b842d9 · 2024-01-06T04:01:09.000Z
Inline a few utility functions around MIR

Most of them are small enough to benefit from inlining.
diff --git a/compiler/rustc_data_structures/src/graph/dominators/mod.rs b/compiler/rustc_data_structures/src/graph/dominators/mod.rs
@@ -394,6 +394,7 @@ impl<Node: Idx> Dominators<Node> {
     /// # Panics
     ///
     /// Panics if `b` is unreachable.
+    #[inline]
     pub fn dominates(&self, a: Node, b: Node) -> bool {
         match &self.kind {
             Kind::Path => a.index() <= b.index(),
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -1576,6 +1576,7 @@ impl Location {
     ///
     /// Note that if this location represents a terminator, then the
     /// resulting location would be out of bounds and invalid.
+    #[inline]
     pub fn successor_within_block(&self) -> Location {
         Location { block: self.block, statement_index: self.statement_index + 1 }
     }
@@ -1612,6 +1613,7 @@ impl Location {
         false
     }
 
+    #[inline]
     pub fn dominates(&self, other: Location, dominators: &Dominators<BasicBlock>) -> bool {
         if self.block == other.block {
             self.statement_index <= other.statement_index
@@ -1631,6 +1633,7 @@ pub enum DefLocation {
 }
 
 impl DefLocation {
+    #[inline]
     pub fn dominates(self, location: Location, dominators: &Dominators<BasicBlock>) -> bool {
         match self {
             DefLocation::Argument => true,
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
@@ -26,6 +26,7 @@ impl SwitchTargets {
     }
 
     /// Inverse of `SwitchTargets::static_if`.
+    #[inline]
     pub fn as_static_if(&self) -> Option<(u128, BasicBlock, BasicBlock)> {
         if let &[value] = &self.values[..]
             && let &[then, else_] = &self.targets[..]
@@ -37,6 +38,7 @@ impl SwitchTargets {
     }
 
     /// Returns the fallback target that is jumped to when none of the values match the operand.
+    #[inline]
     pub fn otherwise(&self) -> BasicBlock {
         *self.targets.last().unwrap()
     }
@@ -47,22 +49,26 @@ impl SwitchTargets {
     /// including the `otherwise` fallback target.
     ///
     /// Note that this may yield 0 elements. Only the `otherwise` branch is mandatory.
+    #[inline]
     pub fn iter(&self) -> SwitchTargetsIter<'_> {
         SwitchTargetsIter { inner: iter::zip(&self.values, &self.targets) }
     }
 
     /// Returns a slice with all possible jump targets (including the fallback target).
+    #[inline]
     pub fn all_targets(&self) -> &[BasicBlock] {
         &self.targets
     }
 
+    #[inline]
     pub fn all_targets_mut(&mut self) -> &mut [BasicBlock] {
         &mut self.targets
     }
 
     /// Finds the `BasicBlock` to which this `SwitchInt` will branch given the
     /// specific value. This cannot fail, as it'll return the `otherwise`
     /// branch if there's not a specific match for the value.
+    #[inline]
     pub fn target_for_value(&self, value: u128) -> BasicBlock {
         self.iter().find_map(|(v, t)| (v == value).then_some(t)).unwrap_or_else(|| self.otherwise())
     }
@@ -75,10 +81,12 @@ pub struct SwitchTargetsIter<'a> {
 impl<'a> Iterator for SwitchTargetsIter<'a> {
     type Item = (u128, BasicBlock);
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         self.inner.next().map(|(val, bb)| (*val, *bb))
     }
 
+    #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         self.inner.size_hint()
     }
@@ -330,28 +338,34 @@ pub type SuccessorsMut<'a> =
     iter::Chain<std::option::IntoIter<&'a mut BasicBlock>, slice::IterMut<'a, BasicBlock>>;
 
 impl<'tcx> Terminator<'tcx> {
+    #[inline]
     pub fn successors(&self) -> Successors<'_> {
         self.kind.successors()
     }
 
+    #[inline]
     pub fn successors_mut(&mut self) -> SuccessorsMut<'_> {
         self.kind.successors_mut()
     }
 
+    #[inline]
     pub fn unwind(&self) -> Option<&UnwindAction> {
         self.kind.unwind()
     }
 
+    #[inline]
     pub fn unwind_mut(&mut self) -> Option<&mut UnwindAction> {
         self.kind.unwind_mut()
     }
 }
 
 impl<'tcx> TerminatorKind<'tcx> {
+    #[inline]
     pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<'tcx> {
         TerminatorKind::SwitchInt { discr: cond, targets: SwitchTargets::static_if(0, f, t) }
     }
 
+    #[inline]
     pub fn successors(&self) -> Successors<'_> {
         use self::TerminatorKind::*;
         match *self {
@@ -392,6 +406,7 @@ impl<'tcx> TerminatorKind<'tcx> {
         }
     }
 
+    #[inline]
     pub fn successors_mut(&mut self) -> SuccessorsMut<'_> {
         use self::TerminatorKind::*;
         match *self {
@@ -430,6 +445,7 @@ impl<'tcx> TerminatorKind<'tcx> {
         }
     }
 
+    #[inline]
     pub fn unwind(&self) -> Option<&UnwindAction> {
         match *self {
             TerminatorKind::Goto { .. }
@@ -449,6 +465,7 @@ impl<'tcx> TerminatorKind<'tcx> {
         }
     }
 
+    #[inline]
     pub fn unwind_mut(&mut self) -> Option<&mut UnwindAction> {
         match *self {
             TerminatorKind::Goto { .. }
@@ -468,13 +485,15 @@ impl<'tcx> TerminatorKind<'tcx> {
         }
     }
 
+    #[inline]
     pub fn as_switch(&self) -> Option<(&Operand<'tcx>, &SwitchTargets)> {
         match self {
             TerminatorKind::SwitchInt { discr, targets } => Some((discr, targets)),
             _ => None,
         }
     }
 
+    #[inline]
     pub fn as_goto(&self) -> Option<BasicBlock> {
         match self {
             TerminatorKind::Goto { target } => Some(*target),
diff --git a/compiler/rustc_mir_transform/src/ssa.rs b/compiler/rustc_mir_transform/src/ssa.rs
@@ -94,6 +94,7 @@ impl SsaLocals {
         self.direct_uses[local]
     }
 
+    #[inline]
     pub fn assignment_dominates(
         &self,
         dominators: &Dominators<BasicBlock>,

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ impl SwitchTargets {`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	/// Inverse of `SwitchTargets::static_if`.
	`29`	`+ #[inline]`
`29`	`30`	`pub fn as_static_if(&self) -> Option<(u128, BasicBlock, BasicBlock)> {`
`30`	`31`	`if let &[value] = &self.values[..]`
`31`	`32`	`&& let &[then, else_] = &self.targets[..]`
`@@ -37,6 +38,7 @@ impl SwitchTargets {`
`37`	`38`	`}`
`38`	`39`
`39`	`40`	`/// Returns the fallback target that is jumped to when none of the values match the operand.`
	`41`	`+ #[inline]`
`40`	`42`	`pub fn otherwise(&self) -> BasicBlock {`
`41`	`43`	`*self.targets.last().unwrap()`
`42`	`44`	`}`
`@@ -47,22 +49,26 @@ impl SwitchTargets {`
`47`	`49`	/// including the `otherwise` fallback target.
`48`	`50`	`///`
`49`	`51`	/// Note that this may yield 0 elements. Only the `otherwise` branch is mandatory.
	`52`	`+ #[inline]`
`50`	`53`	`pub fn iter(&self) -> SwitchTargetsIter<'_> {`
`51`	`54`	`SwitchTargetsIter { inner: iter::zip(&self.values, &self.targets) }`
`52`	`55`	`}`
`53`	`56`
`54`	`57`	`/// Returns a slice with all possible jump targets (including the fallback target).`
	`58`	`+ #[inline]`
`55`	`59`	`pub fn all_targets(&self) -> &[BasicBlock] {`
`56`	`60`	`&self.targets`
`57`	`61`	`}`
`58`	`62`
	`63`	`+ #[inline]`
`59`	`64`	`pub fn all_targets_mut(&mut self) -> &mut [BasicBlock] {`
`60`	`65`	`&mut self.targets`
`61`	`66`	`}`
`62`	`67`
`63`	`68`	/// Finds the `BasicBlock` to which this `SwitchInt` will branch given the
`64`	`69`	/// specific value. This cannot fail, as it'll return the `otherwise`
`65`	`70`	`/// branch if there's not a specific match for the value.`
	`71`	`+ #[inline]`
`66`	`72`	`pub fn target_for_value(&self, value: u128) -> BasicBlock {`
`67`	`73`	`self.iter().find_map(\|(v, t)\| (v == value).then_some(t)).unwrap_or_else(\|\| self.otherwise())`
`68`	`74`	`}`
`@@ -75,10 +81,12 @@ pub struct SwitchTargetsIter<'a> {`
`75`	`81`	`impl<'a> Iterator for SwitchTargetsIter<'a> {`
`76`	`82`	`type Item = (u128, BasicBlock);`
`77`	`83`
	`84`	`+ #[inline]`
`78`	`85`	`fn next(&mut self) -> Option<Self::Item> {`
`79`	`86`	`self.inner.next().map(\|(val, bb)\| (val, bb))`
`80`	`87`	`}`
`81`	`88`
	`89`	`+ #[inline]`
`82`	`90`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`83`	`91`	`self.inner.size_hint()`
`84`	`92`	`}`
`@@ -330,28 +338,34 @@ pub type SuccessorsMut<'a> =`
`330`	`338`	`iter::Chain<std::option::IntoIter<&'a mut BasicBlock>, slice::IterMut<'a, BasicBlock>>;`
`331`	`339`
`332`	`340`	`impl<'tcx> Terminator<'tcx> {`
	`341`	`+ #[inline]`
`333`	`342`	`pub fn successors(&self) -> Successors<'_> {`
`334`	`343`	`self.kind.successors()`
`335`	`344`	`}`
`336`	`345`
	`346`	`+ #[inline]`
`337`	`347`	`pub fn successors_mut(&mut self) -> SuccessorsMut<'_> {`
`338`	`348`	`self.kind.successors_mut()`
`339`	`349`	`}`
`340`	`350`
	`351`	`+ #[inline]`
`341`	`352`	`pub fn unwind(&self) -> Option<&UnwindAction> {`
`342`	`353`	`self.kind.unwind()`
`343`	`354`	`}`
`344`	`355`
	`356`	`+ #[inline]`
`345`	`357`	`pub fn unwind_mut(&mut self) -> Option<&mut UnwindAction> {`
`346`	`358`	`self.kind.unwind_mut()`
`347`	`359`	`}`
`348`	`360`	`}`
`349`	`361`
`350`	`362`	`impl<'tcx> TerminatorKind<'tcx> {`
	`363`	`+ #[inline]`
`351`	`364`	`pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<'tcx> {`
`352`	`365`	`TerminatorKind::SwitchInt { discr: cond, targets: SwitchTargets::static_if(0, f, t) }`
`353`	`366`	`}`
`354`	`367`
	`368`	`+ #[inline]`
`355`	`369`	`pub fn successors(&self) -> Successors<'_> {`
`356`	`370`	`use self::TerminatorKind::*;`
`357`	`371`	`match *self {`
`@@ -392,6 +406,7 @@ impl<'tcx> TerminatorKind<'tcx> {`
`392`	`406`	`}`
`393`	`407`	`}`
`394`	`408`
	`409`	`+ #[inline]`
`395`	`410`	`pub fn successors_mut(&mut self) -> SuccessorsMut<'_> {`
`396`	`411`	`use self::TerminatorKind::*;`
`397`	`412`	`match *self {`
`@@ -430,6 +445,7 @@ impl<'tcx> TerminatorKind<'tcx> {`
`430`	`445`	`}`
`431`	`446`	`}`
`432`	`447`
	`448`	`+ #[inline]`
`433`	`449`	`pub fn unwind(&self) -> Option<&UnwindAction> {`
`434`	`450`	`match *self {`
`435`	`451`	`TerminatorKind::Goto { .. }`
`@@ -449,6 +465,7 @@ impl<'tcx> TerminatorKind<'tcx> {`
`449`	`465`	`}`
`450`	`466`	`}`
`451`	`467`
	`468`	`+ #[inline]`
`452`	`469`	`pub fn unwind_mut(&mut self) -> Option<&mut UnwindAction> {`
`453`	`470`	`match *self {`
`454`	`471`	`TerminatorKind::Goto { .. }`
`@@ -468,13 +485,15 @@ impl<'tcx> TerminatorKind<'tcx> {`
`468`	`485`	`}`
`469`	`486`	`}`
`470`	`487`
	`488`	`+ #[inline]`
`471`	`489`	`pub fn as_switch(&self) -> Option<(&Operand<'tcx>, &SwitchTargets)> {`
`472`	`490`	`match self {`
`473`	`491`	`TerminatorKind::SwitchInt { discr, targets } => Some((discr, targets)),`
`474`	`492`	`_ => None,`
`475`	`493`	`}`
`476`	`494`	`}`
`477`	`495`
	`496`	`+ #[inline]`
`478`	`497`	`pub fn as_goto(&self) -> Option<BasicBlock> {`
`479`	`498`	`match self {`
`480`	`499`	`TerminatorKind::Goto { target } => Some(*target),`
Original file line number	Diff line number	Diff line change
`@@ -94,6 +94,7 @@ impl SsaLocals {`
`94`	`94`	`self.direct_uses[local]`
`95`	`95`	`}`
`96`	`96`
	`97`	`+ #[inline]`
`97`	`98`	`pub fn assignment_dominates(`
`98`	`99`	`&self,`
`99`	`100`	`dominators: &Dominators<BasicBlock>,`