1use std::cell::RefCell;
2use std::collections::hash_map::Entry;
3use std::sync::atomic::Ordering;
4
5use rustc_attr_ir::OptimizeAttr;
6use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
7use rustc_hir::def_id::DefId;
8use rustc_middle::mir::{AnalysisPhase, Body, MirDumper, MirPhase, RuntimePhase};
9use rustc_middle::ty::TyCtxt;
10use rustc_session::Session;
11use rustc_session::config::OptLevel;
12use rustc_span::bug;
13use tracing::trace;
14
15use crate::lint::lint_body;
16use crate::{diagnostics, validate};
17
18#[doc =
r" Maps MIR pass names to a snake case form to match profiling naming style"]
const PASS_TO_PROFILER_NAMES:
::std::thread::LocalKey<RefCell<FxHashMap<&'static str, &'static str>>> =
{
#[allow(mismatched_lifetime_syntaxes)]
#[inline]
fn __rust_std_internal_init_fn(_lifetime_elision:
::std::marker::PhantomData<&'static ()>)
-> RefCell<FxHashMap<&'static str, &'static str>> {
{ RefCell::new(FxHashMap::default()) }
}
unsafe {
::std::thread::LocalKey::new(const {
if ::std::mem::needs_drop::<RefCell<FxHashMap<&'static str,
&'static str>>>() {
|__rust_std_internal_init|
{
#[thread_local]
static __RUST_STD_INTERNAL_VAL:
::std::thread::local_impl::LazyStorage<RefCell<FxHashMap<&'static str,
&'static str>>, ()> =
::std::thread::local_impl::LazyStorage::new();
__RUST_STD_INTERNAL_VAL.get_or_init(__rust_std_internal_init,
|| __rust_std_internal_init_fn(::std::marker::PhantomData))
}
} else {
|__rust_std_internal_init|
{
#[thread_local]
static __RUST_STD_INTERNAL_VAL:
::std::thread::local_impl::LazyStorage<RefCell<FxHashMap<&'static str,
&'static str>>, !> =
::std::thread::local_impl::LazyStorage::new();
__RUST_STD_INTERNAL_VAL.get_or_init(__rust_std_internal_init,
|| __rust_std_internal_init_fn(::std::marker::PhantomData))
}
}
})
}
};thread_local! {
19 static PASS_TO_PROFILER_NAMES: RefCell<FxHashMap<&'static str, &'static str>> = {
21 RefCell::new(FxHashMap::default())
22 };
23}
24
25fn to_profiler_name(type_name: &'static str) -> &'static str {
27 PASS_TO_PROFILER_NAMES.with(|names| match names.borrow_mut().entry(type_name) {
28 Entry::Occupied(e) => *e.get(),
29 Entry::Vacant(e) => {
30 let snake_case: String = type_name
31 .chars()
32 .flat_map(|c| {
33 if c.is_ascii_uppercase() {
34 ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
['_', c.to_ascii_lowercase()]))vec!['_', c.to_ascii_lowercase()]
35 } else if c == '-' {
36 ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
['_']))vec!['_']
37 } else {
38 ::alloc::boxed::box_assume_init_into_vec_unsafe(::alloc::intrinsics::write_box_via_move(::alloc::boxed::Box::new_uninit(),
[c]))vec![c]
39 }
40 })
41 .collect();
42 let result = &*String::leak(::alloc::__export::must_use({
::alloc::fmt::format(format_args!("mir_pass{0}", snake_case))
})format!("mir_pass{}", snake_case));
43 e.insert(result);
44 result
45 }
46 })
47}
48
49const fn simplify_pass_type_name(name: &'static str) -> &'static str {
62 let bytes = name.as_bytes();
66 let mut i = bytes.len();
67 while i > 0 && bytes[i - 1] != b':' {
68 i -= 1;
69 }
70 let (_, bytes) = bytes.split_at(i);
71
72 let mut i = 0;
75 while i < bytes.len() && bytes[i] != b'<' {
76 i += 1;
77 }
78 let (bytes, _) = bytes.split_at(i);
79
80 match std::str::from_utf8(bytes) {
81 Ok(name) => name,
82 Err(_) => ::core::panicking::panic_default_msg()panic!(),
83 }
84}
85
86#[derive(#[automatically_derived]impl ::core::marker::Copy for PassPolicy { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for PassPolicy {
}
#[automatically_derived]impl ::core::clone::Clone for PassPolicy {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<bool>;
*self
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for PassPolicy {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Required =>
::core::fmt::Formatter::write_str(f, "Required"),
Self::Optional { enabled_by_default: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Optional enabled_by_default", &__self_0),
}
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
PassPolicy {
}
#[automatically_derived]impl ::core::cmp::PartialEq for PassPolicy {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Optional { enabled_by_default: __self_0 },
Self::Optional { enabled_by_default: __arg1_0 }) =>
__self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for PassPolicy {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<bool>;
}
}Eq)]
88pub(crate) enum PassPolicy {
89 Required,
94 Optional {
96 enabled_by_default: bool,
99 },
100}
101
102impl PassPolicy {
103 pub(crate) fn optional(enabled_by_default: bool) -> Self {
105 Self::Optional { enabled_by_default }
106 }
107}
108
109pub(super) trait MirPass<'tcx> {
113 fn name(&self) -> &'static str {
114 const { simplify_pass_type_name(std::any::type_name::<Self>()) }
115 }
116
117 fn profiler_name(&self) -> &'static str {
118 to_profiler_name(self.name())
119 }
120
121 fn policy(&self, ctx: &PassCtx<'_>) -> PassPolicy;
123
124 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>);
125
126 fn is_mir_dump_enabled(&self) -> bool {
127 true
128 }
129}
130
131#[derive(#[automatically_derived]impl<'sess> ::core::marker::Copy for PassCtx<'sess> {
}Copy, #[automatically_derived]#[doc(hidden)]unsafe impl<'sess>
::core::clone::TrivialClone for PassCtx<'sess> {
}
#[automatically_derived]impl<'sess> ::core::clone::Clone for PassCtx<'sess> {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<&'sess Session>;
let _: ::core::clone::AssertParamIsClone<usize>;
*self
}
}Clone)]
132pub(super) struct PassCtx<'sess> {
133 session: &'sess Session,
135 body_mir_opt_level: usize,
137}
138
139impl<'sess> PassCtx<'sess> {
140 pub(super) fn for_body(tcx: TyCtxt<'sess>, def_id: DefId) -> Self {
141 let body_mir_opt_level = if !tcx.def_kind(def_id).has_codegen_attrs() {
142 tcx.sess.mir_opt_level()
143 } else {
144 let attr_opt_level = match tcx.codegen_fn_attrs(def_id).optimize {
145 OptimizeAttr::Default => tcx.sess.mir_opt_level(),
146 OptimizeAttr::Speed => OptLevel::Aggressive.mir_opt_level(),
147 OptimizeAttr::Size => OptLevel::SizeMin.mir_opt_level(),
148 OptimizeAttr::DoNotOptimize => OptLevel::No.mir_opt_level(),
149 };
150 attr_opt_level.min(tcx.sess.mir_opt_level())
157 };
158 Self { session: tcx.sess, body_mir_opt_level }
159 }
160
161 pub(super) fn mir_opt_level(&self) -> usize {
163 self.body_mir_opt_level
164 }
165}
166
167impl std::ops::Deref for PassCtx<'_> {
168 type Target = Session;
169
170 fn deref(&self) -> &Self::Target {
171 self.session
172 }
173}
174
175pub(super) trait MirLint<'tcx> {
178 fn name(&self) -> &'static str {
179 const { simplify_pass_type_name(std::any::type_name::<Self>()) }
180 }
181
182 fn run_lint(&self, tcx: TyCtxt<'tcx>, body: &Body<'tcx>);
183}
184
185#[derive(#[automatically_derived]impl<T: ::core::fmt::Debug> ::core::fmt::Debug for
Lint<T> {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field1_finish(f, "Lint",
&&self.0)
}
}Debug, #[automatically_derived]impl<T: ::core::clone::Clone> ::core::clone::Clone for
Lint<T> {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { Lint(::core::clone::Clone::clone(&self.0)) }
}Clone)]
187pub(super) struct Lint<T>(pub T);
188
189impl<'tcx, T> MirPass<'tcx> for Lint<T>
190where
191 T: MirLint<'tcx>,
192{
193 fn name(&self) -> &'static str {
194 self.0.name()
195 }
196
197 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
198 self.0.run_lint(tcx, body)
199 }
200
201 fn is_mir_dump_enabled(&self) -> bool {
202 false
203 }
204
205 fn policy(&self, _ctx: &PassCtx<'_>) -> PassPolicy {
206 PassPolicy::optional(true)
207 }
208}
209
210pub(super) struct WithMinOptLevel<T>(pub usize, pub T);
211
212impl<'tcx, T> MirPass<'tcx> for WithMinOptLevel<T>
213where
214 T: MirPass<'tcx>,
215{
216 fn name(&self) -> &'static str {
217 self.1.name()
218 }
219
220 fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
221 self.1.run_pass(tcx, body)
222 }
223
224 fn policy(&self, ctx: &PassCtx<'_>) -> PassPolicy {
225 let policy = self.1.policy(ctx);
226 match policy {
227 PassPolicy::Required => ::rustc_span::macros::bug_impl(None,
format_args!("required pass cannot be gated by an opt level"),
Location::caller())bug!("required pass cannot be gated by an opt level"),
228 PassPolicy::Optional { enabled_by_default } => PassPolicy::Optional {
229 enabled_by_default: enabled_by_default && ctx.mir_opt_level() >= self.0,
230 },
231 }
232 }
233}
234
235pub(super) fn run_passes_no_validate<'tcx>(
238 tcx: TyCtxt<'tcx>,
239 body: &mut Body<'tcx>,
240 passes: &[&dyn MirPass<'tcx>],
241 phase_change: Option<MirPhase>,
242) {
243 run_passes_inner(tcx, body, passes, phase_change, false);
244}
245
246pub(super) fn run_passes<'tcx>(
248 tcx: TyCtxt<'tcx>,
249 body: &mut Body<'tcx>,
250 passes: &[&dyn MirPass<'tcx>],
251 phase_change: Option<MirPhase>,
252) {
253 run_passes_inner(tcx, body, passes, phase_change, true);
254}
255
256pub(super) fn should_run_pass<'tcx, P>(pass: &P, ctx: &PassCtx<'_>) -> bool
257where
258 P: MirPass<'tcx> + ?Sized,
259{
260 let name = pass.name();
261 let pass_override = || {
262 ctx.opts
263 .unstable_opts
264 .mir_enable_passes
265 .iter()
266 .rev()
267 .find_map(|(name_, polarity)| if name == name_ { Some(*polarity) } else { None })
268 };
269
270 match pass.policy(ctx) {
271 PassPolicy::Required => true,
272 PassPolicy::Optional { enabled_by_default } => {
273 if let Some(o) = pass_override() {
274 {
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/c7d5ba59d8e11ee2e2204b173458eec4cb41c973/compiler/rustc_mir_transform/src/pass_manager.rs:274",
"rustc_mir_transform::pass_manager",
::tracing::Level::TRACE,
::tracing_core::__macro_support::Option::Some("/rustc-dev/c7d5ba59d8e11ee2e2204b173458eec4cb41c973/compiler/rustc_mir_transform/src/pass_manager.rs"),
::tracing_core::__macro_support::Option::Some(274u32),
::tracing_core::__macro_support::Option::Some("rustc_mir_transform::pass_manager"),
::tracing_core::field::FieldSet::new(&["message",
{
const NAME:
::tracing::__macro_support::FieldName<{
::tracing::__macro_support::FieldName::len("pass")
}> =
::tracing::__macro_support::FieldName::new("pass");
NAME.as_str()
}], ::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::TRACE <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::TRACE <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&format_args!("{0} as requested by flag",
if o { "Running" } else { "Not running" }) as
&dyn ::tracing::field::Value)),
(::tracing::__macro_support::Option::Some(&::tracing::field::display(&name)
as &dyn ::tracing::field::Value))])
});
} else { ; }
};trace!(
275 pass = %name,
276 "{} as requested by flag",
277 if o { "Running" } else { "Not running" }
278 );
279 o
280 } else {
281 enabled_by_default
282 }
283 }
284 }
285}
286
287fn run_passes_inner<'tcx>(
288 tcx: TyCtxt<'tcx>,
289 body: &mut Body<'tcx>,
290 passes: &[&dyn MirPass<'tcx>],
291 phase_change: Option<MirPhase>,
292 validate_each: bool,
293) {
294 let overridden_passes = &tcx.sess.opts.unstable_opts.mir_enable_passes;
295 {
use ::tracing::__macro_support::Callsite as _;
static __CALLSITE: ::tracing::callsite::DefaultCallsite =
{
static META: ::tracing::Metadata<'static> =
{
::tracing_core::metadata::Metadata::new("event /rustc-dev/c7d5ba59d8e11ee2e2204b173458eec4cb41c973/compiler/rustc_mir_transform/src/pass_manager.rs:295",
"rustc_mir_transform::pass_manager",
::tracing::Level::TRACE,
::tracing_core::__macro_support::Option::Some("/rustc-dev/c7d5ba59d8e11ee2e2204b173458eec4cb41c973/compiler/rustc_mir_transform/src/pass_manager.rs"),
::tracing_core::__macro_support::Option::Some(295u32),
::tracing_core::__macro_support::Option::Some("rustc_mir_transform::pass_manager"),
::tracing_core::field::FieldSet::new(&[{
const NAME:
::tracing::__macro_support::FieldName<{
::tracing::__macro_support::FieldName::len("overridden_passes")
}> =
::tracing::__macro_support::FieldName::new("overridden_passes");
NAME.as_str()
}], ::tracing_core::callsite::Identifier(&__CALLSITE)),
::tracing::metadata::Kind::EVENT)
};
::tracing::callsite::DefaultCallsite::new(&META)
};
let enabled =
::tracing::Level::TRACE <= ::tracing::level_filters::STATIC_MAX_LEVEL
&&
::tracing::Level::TRACE <=
::tracing::level_filters::LevelFilter::current() &&
{
let interest = __CALLSITE.interest();
!interest.is_never() &&
::tracing::__macro_support::__is_enabled(__CALLSITE.metadata(),
interest)
};
if enabled {
(|value_set: ::tracing::field::ValueSet|
{
let meta = __CALLSITE.metadata();
::tracing::Event::dispatch(meta, &value_set);
;
})({
#[allow(unused_imports)]
use ::tracing::field::{debug, display, Value};
__CALLSITE.metadata().fields().value_set_all(&[(::tracing::__macro_support::Option::Some(&::tracing::field::debug(&overridden_passes)
as &dyn ::tracing::field::Value))])
});
} else { ; }
};trace!(?overridden_passes);
296
297 let named_passes: FxIndexSet<_> =
298 overridden_passes.iter().map(|(name, _)| name.as_str()).collect();
299
300 let mut unknown_found = false;
301 for &name in named_passes.difference(&*crate::PASS_NAMES) {
302 tcx.dcx().emit_warn(diagnostics::UnknownPassName { name });
303 unknown_found = true;
304 }
305
306 if unknown_found {
307 let mut valid_pass_names = crate::PASS_NAMES.iter().copied().collect::<Vec<_>>();
308 valid_pass_names.sort();
309 tcx.dcx().emit_note(diagnostics::ValidPassNames { valid_passes: valid_pass_names.into() });
310 }
311
312 #[cfg(debug_assertions)]
314 {
315 let used_passes: FxIndexSet<_> = passes.iter().map(|p| p.name()).collect();
316
317 let undeclared = used_passes.difference(&*crate::PASS_NAMES).collect::<Vec<_>>();
318 if let Some((name, rest)) = undeclared.split_first() {
319 let mut err =
320 tcx.dcx().struct_bug(::alloc::__export::must_use({
::alloc::fmt::format(format_args!("pass `{0}` is not declared in `PASS_NAMES`",
name))
})format!("pass `{name}` is not declared in `PASS_NAMES`"));
321 for name in rest {
322 err.note(::alloc::__export::must_use({
::alloc::fmt::format(format_args!("pass `{0}` is also not declared in `PASS_NAMES`",
name))
})format!("pass `{name}` is also not declared in `PASS_NAMES`"));
323 }
324 err.emit_bug();
325 }
326 }
327
328 let prof_arg = tcx.sess.prof.enabled().then(|| ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("{0:?}", body.source.def_id()))
})format!("{:?}", body.source.def_id()));
329
330 if !body.should_skip() {
331 let validate = validate_each & tcx.sess.opts.unstable_opts.validate_mir;
332 let lint = tcx.sess.opts.unstable_opts.lint_mir;
333
334 let ctx = PassCtx::for_body(tcx, body.source.def_id());
335
336 for pass in passes {
337 let pass_name = pass.name();
338
339 if !should_run_pass(*pass, &ctx) {
340 continue;
341 };
342
343 if body.phase == MirPhase::Runtime(RuntimePhase::PostCleanup)
344 && phase_change == Some(MirPhase::Runtime(RuntimePhase::Optimized))
345 && let Some(limit) = &tcx.sess.opts.unstable_opts.mir_opt_bisect_limit
346 && #[allow(non_exhaustive_omitted_patterns)] match pass.policy(&ctx) {
PassPolicy::Optional { .. } => true,
_ => false,
}matches!(pass.policy(&ctx), PassPolicy::Optional { .. })
347 && limited_by_opt_bisect(
348 tcx,
349 tcx.def_path_debug_str(body.source.def_id()),
350 *limit,
351 *pass,
352 )
353 {
354 continue;
355 }
356
357 let dumper = if pass.is_mir_dump_enabled()
358 && let Some(dumper) = MirDumper::new(tcx, pass_name, body)
359 {
360 Some(dumper.set_show_pass_num().set_disambiguator(&"before"))
361 } else {
362 None
363 };
364
365 if let Some(dumper) = dumper.as_ref() {
366 dumper.dump_mir(body);
367 }
368
369 if let Some(prof_arg) = &prof_arg {
370 tcx.sess
371 .prof
372 .generic_activity_with_arg(pass.profiler_name(), &**prof_arg)
373 .run(|| pass.run_pass(tcx, body));
374 } else {
375 pass.run_pass(tcx, body);
376 }
377
378 if let Some(dumper) = dumper {
379 dumper.set_disambiguator(&"after").dump_mir(body);
380 }
381
382 if validate {
383 validate_body(tcx, body, ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("after pass {0}", pass_name))
})format!("after pass {pass_name}"));
384 }
385 if lint {
386 lint_body(tcx, body, ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("after pass {0}", pass_name))
})format!("after pass {pass_name}"));
387 }
388
389 body.pass_count += 1;
390 }
391 }
392
393 if let Some(new_phase) = phase_change {
394 if body.phase >= new_phase {
395 {
::core::panicking::panic_fmt(format_args!("Invalid MIR phase transition from {0:?} to {1:?}",
body.phase, new_phase));
};panic!("Invalid MIR phase transition from {:?} to {:?}", body.phase, new_phase);
396 }
397
398 body.phase = new_phase;
399 body.pass_count = 0;
400
401 dump_mir_for_phase_change(tcx, body);
402
403 let validate = (validate_each
404 && tcx.sess.opts.unstable_opts.validate_mir
405 && !body.should_skip()
406 && (new_phase != MirPhase::Analysis(AnalysisPhase::PostCleanup)))
409 || new_phase == MirPhase::Runtime(RuntimePhase::Optimized);
410 let lint = tcx.sess.opts.unstable_opts.lint_mir & !body.should_skip();
411 if validate {
412 validate_body(tcx, body, ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("after phase change to {0}",
new_phase.name()))
})format!("after phase change to {}", new_phase.name()));
413 }
414 if lint {
415 lint_body(tcx, body, ::alloc::__export::must_use({
::alloc::fmt::format(format_args!("after phase change to {0}",
new_phase.name()))
})format!("after phase change to {}", new_phase.name()));
416 }
417
418 body.pass_count = 1;
419 }
420}
421
422pub(super) fn validate_body<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>, when: String) {
423 validate::Validator { when }.run_pass(tcx, body);
424}
425
426pub(super) fn dump_mir_for_phase_change<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
427 {
match (&body.pass_count, &0) {
(left_val, right_val) => {
if !(*left_val == *right_val) {
let kind = ::core::panicking::AssertKind::Eq;
::core::panicking::assert_failed(kind, &*left_val,
&*right_val, ::core::option::Option::None);
}
}
}
};assert_eq!(body.pass_count, 0);
428 if let Some(dumper) = MirDumper::new(tcx, body.phase.name(), body) {
429 dumper.set_show_pass_num().set_disambiguator(&"after").dump_mir(body)
430 }
431}
432
433fn limited_by_opt_bisect<'tcx, P>(
434 tcx: TyCtxt<'tcx>,
435 def_path: String,
436 limit: usize,
437 pass: &P,
438) -> bool
439where
440 P: MirPass<'tcx> + ?Sized,
441{
442 let current_opt_bisect_count =
443 tcx.sess.mir_opt_bisect_eval_count.fetch_add(1, Ordering::Relaxed);
444
445 let can_run = current_opt_bisect_count < limit;
446
447 if can_run {
448 {
::std::io::_eprint(format_args!("BISECT: running pass ({0}) {1} on {2}\n",
current_opt_bisect_count + 1, pass.name(), def_path));
};eprintln!(
449 "BISECT: running pass ({}) {} on {}",
450 current_opt_bisect_count + 1,
451 pass.name(),
452 def_path
453 );
454 } else {
455 {
::std::io::_eprint(format_args!("BISECT: NOT running pass ({0}) {1} on {2}\n",
current_opt_bisect_count + 1, pass.name(), def_path));
};eprintln!(
456 "BISECT: NOT running pass ({}) {} on {}",
457 current_opt_bisect_count + 1,
458 pass.name(),
459 def_path
460 );
461 }
462
463 !can_run
464}