use cranelift_codegen::{
entity::SecondaryMap,
- ir::{entities::AnyEntity, function::DisplayFunctionAnnotations},
+ ir::entities::AnyEntity,
write::{FuncWriter, PlainWriter},
};
-use rustc_middle::ty::layout::FnAbiExt;
+use rustc_middle::ty::layout::FnAbiOf;
use rustc_session::config::OutputType;
-use rustc_target::abi::call::FnAbi;
use crate::prelude::*;
-#[derive(Debug)]
+#[derive(Clone, 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!("abi {:?}", FnAbi::of_instance(&RevealAllLayoutCx(tcx), instance, &[])),
+ format!(
+ "abi {:?}",
+ RevealAllLayoutCx(tcx).fn_abi_of_instance(instance, ty::List::empty())
+ ),
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) => {
&mut self,
w: &mut dyn fmt::Write,
func: &Function,
- reg_info: Option<&isa::RegInfo>,
) -> Result<bool, fmt::Error> {
for comment in &self.global_comments {
if !comment.is_empty() {
writeln!(w)?;
}
- self.super_preamble(w, func, reg_info)
+ self.super_preamble(w, func)
}
fn write_entity_definition(
&mut self,
w: &mut dyn fmt::Write,
func: &Function,
- isa: Option<&dyn isa::TargetIsa>,
block: Block,
indent: usize,
) -> fmt::Result {
- PlainWriter.write_block_header(w, func, isa, block, indent)
+ PlainWriter.write_block_header(w, func, block, indent)
}
fn write_instruction(
w: &mut dyn fmt::Write,
func: &Function,
aliases: &SecondaryMap<Value, Vec<Value>>,
- isa: Option<&dyn isa::TargetIsa>,
inst: Inst,
indent: usize,
) -> fmt::Result {
- PlainWriter.write_instruction(w, func, aliases, isa, inst, indent)?;
+ PlainWriter.write_instruction(w, func, aliases, inst, indent)?;
if let Some(comment) = self.entity_comments.get(&inst.into()) {
writeln!(w, "; {}", comment.replace('\n', "\n; "))?;
}
}
}
-#[cfg(debug_assertions)]
impl FunctionCx<'_, '_, '_> {
pub(crate) fn add_global_comment<S: Into<String>>(&mut self, comment: S) {
self.clif_comments.add_global_comment(comment);
tcx.sess.opts.output_types.contains_key(&OutputType::LlvmAssembly)
}
-pub(crate) fn write_ir_file<'tcx>(
- tcx: TyCtxt<'tcx>,
- name: &str,
+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");
+ let clif_output_dir = tcx.output_filenames(()).with_extension("clif");
match std::fs::create_dir(&clif_output_dir) {
Ok(()) => {}
res @ Err(_) => res.unwrap(),
}
- let clif_file_name = clif_output_dir.join(name);
+ let clif_file_name = clif_output_dir.join(name());
- let res: std::io::Result<()> = try {
- let mut file = std::fs::File::create(clif_file_name)?;
- write(&mut file)?;
- };
+ 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,
- isa: Option<&dyn cranelift_codegen::isa::TargetIsa>,
+ isa: &dyn cranelift_codegen::isa::TargetIsa,
instance: Instance<'tcx>,
- context: &cranelift_codegen::Context,
+ func: &cranelift_codegen::ir::Function,
mut clif_comments: &CommentWriter,
) {
- 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 mut clif = String::new();
- cranelift_codegen::write::decorate_function(
- &mut clif_comments,
- &mut clif,
- &context.func,
- &DisplayFunctionAnnotations {
- isa: Some(&*crate::build_isa(tcx.sess)),
- value_ranges: value_ranges.as_ref(),
- },
- )
- .unwrap();
+ // FIXME work around filename too long errors
+ write_ir_file(
+ tcx,
+ || format!("{}.{}.clif", tcx.symbol_name(instance).name, postfix),
+ |file| {
+ let mut clif = String::new();
+ cranelift_codegen::write::decorate_function(&mut clif_comments, &mut clif, func)
+ .unwrap();
- 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(())
- });
+ for flag in isa.flags().iter() {
+ writeln!(file, "set {}", flag)?;
+ }
+ write!(file, "target {}", isa.triple().architecture.to_string())?;
+ for isa_flag in isa.isa_flags().iter() {
+ write!(file, " {}", isa_flag)?;
+ }
+ writeln!(file, "\n")?;
+ writeln!(file)?;
+ file.write_all(clif.as_bytes())?;
+ Ok(())
+ },
+ );
}
impl fmt::Debug for FunctionCx<'_, '_, '_> {
&mut &self.clif_comments,
&mut clif,
&self.bcx.func,
- &DisplayFunctionAnnotations::default(),
)
.unwrap();
writeln!(f, "\n{}", clif)
projects / rust.git / blobdiff