//! ```
use std::fmt;
+use std::io::Write;
use cranelift_codegen::{
entity::SecondaryMap,
write::{FuncWriter, PlainWriter},
};
+use rustc_middle::ty::layout::FnAbiExt;
use rustc_session::config::OutputType;
+use rustc_target::abi::call::FnAbi;
use crate::prelude::*;
#[derive(Debug)]
pub(crate) struct CommentWriter {
+ enabled: bool,
global_comments: Vec<String>,
entity_comments: FxHashMap<AnyEntity, String>,
}
impl CommentWriter {
pub(crate) fn new<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> Self {
- let global_comments = if cfg!(debug_assertions) {
+ let enabled = should_write_ir(tcx);
+ let global_comments = if enabled {
vec![
format!("symbol {}", tcx.symbol_name(instance).name),
format!("instance {:?}", instance),
- format!(
- "sig {:?}",
- tcx.normalize_erasing_late_bound_regions(
- ParamEnv::reveal_all(),
- &crate::abi::fn_sig_for_fn_abi(tcx, instance)
- )
- ),
+ format!("abi {:?}", FnAbi::of_instance(&RevealAllLayoutCx(tcx), instance, &[])),
String::new(),
]
} else {
vec![]
};
- CommentWriter {
- global_comments,
- entity_comments: FxHashMap::default(),
- }
+ CommentWriter { enabled, global_comments, entity_comments: FxHashMap::default() }
}
}
-#[cfg(debug_assertions)]
impl CommentWriter {
+ pub(crate) fn enabled(&self) -> bool {
+ self.enabled
+ }
+
pub(crate) fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
+ debug_assert!(self.enabled);
self.global_comments.push(comment.into());
}
entity: E,
comment: S,
) {
+ debug_assert!(self.enabled);
+
use std::collections::hash_map::Entry;
match self.entity_comments.entry(entity.into()) {
Entry::Occupied(mut occ) => {
if !comment.is_empty() {
writeln!(w, "; {}", comment)?;
} else {
- writeln!(w, "")?;
+ writeln!(w)?;
}
}
if !self.global_comments.is_empty() {
- writeln!(w, "")?;
+ writeln!(w)?;
}
self.super_preamble(w, func, reg_info)
if let Some(comment) = self.entity_comments.get(&entity) {
writeln!(w, " ; {}", comment.replace('\n', "\n; "))
} else {
- writeln!(w, "")
+ writeln!(w)
}
}
}
}
-#[cfg(debug_assertions)]
-impl<M: Module> FunctionCx<'_, '_, M> {
+impl FunctionCx<'_, '_, '_> {
pub(crate) fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
self.clif_comments.add_global_comment(comment);
}
}
}
+pub(crate) fn should_write_ir(tcx: TyCtxt<'_>) -> bool {
+ tcx.sess.opts.output_types.contains_key(&OutputType::LlvmAssembly)
+}
+
+pub(crate) fn write_ir_file(
+ tcx: TyCtxt<'_>,
+ name: impl FnOnce() -> String,
+ write: impl FnOnce(&mut dyn Write) -> std::io::Result<()>,
+) {
+ if !should_write_ir(tcx) {
+ return;
+ }
+
+ let clif_output_dir = tcx.output_filenames(LOCAL_CRATE).with_extension("clif");
+
+ match std::fs::create_dir(&clif_output_dir) {
+ Ok(()) => {}
+ Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {}
+ res @ Err(_) => res.unwrap(),
+ }
+
+ let clif_file_name = clif_output_dir.join(name());
+
+ let res = std::fs::File::create(clif_file_name).and_then(|mut file| write(&mut file));
+ if let Err(err) = res {
+ tcx.sess.warn(&format!("error writing ir file: {}", err));
+ }
+}
+
pub(crate) fn write_clif_file<'tcx>(
tcx: TyCtxt<'tcx>,
postfix: &str,
context: &cranelift_codegen::Context,
mut clif_comments: &CommentWriter,
) {
- use std::io::Write;
-
- if !cfg!(debug_assertions)
- && !tcx
- .sess
- .opts
- .output_types
- .contains_key(&OutputType::LlvmAssembly)
- {
- return;
- }
+ write_ir_file(
+ tcx,
+ || format!("{}.{}.clif", tcx.symbol_name(instance).name, postfix),
+ |file| {
+ let value_ranges = isa
+ .map(|isa| context.build_value_labels_ranges(isa).expect("value location ranges"));
- let value_ranges = isa.map(|isa| {
- context
- .build_value_labels_ranges(isa)
- .expect("value location ranges")
- });
+ let mut clif = String::new();
+ cranelift_codegen::write::decorate_function(
+ &mut clif_comments,
+ &mut clif,
+ &context.func,
+ &DisplayFunctionAnnotations { isa, value_ranges: value_ranges.as_ref() },
+ )
+ .unwrap();
- let symbol_name = tcx.symbol_name(instance).name;
- let clif_file_name = format!(
- "{}/{}__{}.{}.clif",
- concat!(env!("CARGO_MANIFEST_DIR"), "/target/out/clif"),
- tcx.crate_name(LOCAL_CRATE),
- symbol_name,
- postfix,
- );
-
- let mut clif = String::new();
- cranelift_codegen::write::decorate_function(
- &mut clif_comments,
- &mut clif,
- &context.func,
- &DisplayFunctionAnnotations {
- isa: Some(&*crate::build_isa(
- tcx.sess, true, /* PIC doesn't matter here */
- )),
- value_ranges: value_ranges.as_ref(),
+ writeln!(file, "test compile")?;
+ writeln!(file, "set is_pic")?;
+ writeln!(file, "set enable_simd")?;
+ writeln!(file, "target {} haswell", crate::target_triple(tcx.sess))?;
+ writeln!(file)?;
+ file.write_all(clif.as_bytes())?;
+ Ok(())
},
- )
- .unwrap();
-
- let res: std::io::Result<()> = try {
- let mut file = std::fs::File::create(clif_file_name)?;
- let target_triple = crate::target_triple(tcx.sess);
- writeln!(file, "test compile")?;
- writeln!(file, "set is_pic")?;
- writeln!(file, "set enable_simd")?;
- writeln!(file, "target {} haswell", target_triple)?;
- writeln!(file, "")?;
- file.write(clif.as_bytes())?;
- };
- if let Err(err) = res {
- tcx.sess.warn(&format!("err writing clif file: {}", err));
- }
+ );
}
-impl<M: Module> fmt::Debug for FunctionCx<'_, '_, M> {
+impl fmt::Debug for FunctionCx<'_, '_, '_> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
writeln!(f, "{:?}", self.instance.substs)?;
writeln!(f, "{:?}", self.local_map)?;
projects / rust.git / blobdiff