-#![feature(rustc_private, decl_macro)]
-#![cfg_attr(feature = "jit", feature(never_type, vec_into_raw_parts, once_cell))]
+#![feature(rustc_private)]
+// Note: please avoid adding other feature gates where possible
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
#![warn(unreachable_pub)]
-extern crate snap;
#[macro_use]
extern crate rustc_middle;
extern crate rustc_ast;
extern crate rustc_driver;
use std::any::Any;
+use std::cell::Cell;
use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_codegen_ssa::CodegenResults;
-use rustc_errors::ErrorReported;
+use rustc_errors::ErrorGuaranteed;
+use rustc_metadata::EncodedMetadata;
use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
-use rustc_middle::middle::cstore::EncodedMetadata;
use rustc_session::config::OutputFilenames;
use rustc_session::Session;
+use rustc_span::Symbol;
use cranelift_codegen::isa::TargetIsa;
use cranelift_codegen::settings::{self, Configurable};
mod intrinsics;
mod linkage;
mod main_shim;
-mod metadata;
mod num;
mod optimize;
mod pointer;
mod vtable;
mod prelude {
- pub(crate) use std::convert::{TryFrom, TryInto};
-
- pub(crate) use rustc_span::{Span, FileNameDisplayPreference};
+ pub(crate) use rustc_span::{FileNameDisplayPreference, Span};
pub(crate) use rustc_hir::def_id::{DefId, LOCAL_CRATE};
pub(crate) use rustc_middle::bug;
pub(crate) use rustc_middle::ty::layout::{self, LayoutOf, TyAndLayout};
pub(crate) use rustc_middle::ty::{
self, FloatTy, Instance, InstanceDef, IntTy, ParamEnv, Ty, TyCtxt, TypeAndMut,
- TypeFoldable, UintTy,
+ TypeFoldable, TypeVisitable, UintTy,
};
pub(crate) use rustc_target::abi::{Abi, Scalar, Size, VariantIdx};
pub(crate) use crate::common::*;
pub(crate) use crate::debuginfo::{DebugContext, UnwindContext};
pub(crate) use crate::pointer::Pointer;
- pub(crate) use crate::trap::*;
pub(crate) use crate::value_and_place::{CPlace, CPlaceInner, CValue};
}
struct CodegenCx<'tcx> {
tcx: TyCtxt<'tcx>,
global_asm: String,
+ inline_asm_index: Cell<usize>,
cached_context: Context,
debug_context: Option<DebugContext<'tcx>>,
unwind_context: UnwindContext,
+ cgu_name: Symbol,
}
impl<'tcx> CodegenCx<'tcx> {
backend_config: BackendConfig,
isa: &dyn TargetIsa,
debug_info: bool,
+ cgu_name: Symbol,
) -> Self {
assert_eq!(pointer_ty(tcx), isa.pointer_type());
let unwind_context =
- UnwindContext::new(tcx, isa, matches!(backend_config.codegen_mode, CodegenMode::Aot));
- let debug_context = if debug_info { Some(DebugContext::new(tcx, isa)) } else { None };
+ UnwindContext::new(isa, matches!(backend_config.codegen_mode, CodegenMode::Aot));
+ let debug_context = if debug_info && !tcx.sess.target.options.is_like_windows {
+ Some(DebugContext::new(tcx, isa))
+ } else {
+ None
+ };
CodegenCx {
tcx,
global_asm: String::new(),
+ inline_asm_index: Cell::new(0),
cached_context: Context::new(),
debug_context,
unwind_context,
+ cgu_name,
}
}
}
}
}
- fn target_features(&self, _sess: &Session) -> Vec<rustc_span::Symbol> {
+ fn target_features(&self, _sess: &Session, _allow_unstable: bool) -> Vec<rustc_span::Symbol> {
vec![]
}
CodegenMode::Aot => driver::aot::run_aot(tcx, config, metadata, need_metadata_module),
CodegenMode::Jit | CodegenMode::JitLazy => {
#[cfg(feature = "jit")]
- let _: ! = driver::jit::run_jit(tcx, config);
+ driver::jit::run_jit(tcx, config);
#[cfg(not(feature = "jit"))]
tcx.sess.fatal("jit support was disabled when compiling rustc_codegen_cranelift");
&self,
ongoing_codegen: Box<dyn Any>,
_sess: &Session,
- ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported> {
+ _outputs: &OutputFilenames,
+ ) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorGuaranteed> {
Ok(*ongoing_codegen
.downcast::<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>)>()
.unwrap())
sess: &Session,
codegen_results: CodegenResults,
outputs: &OutputFilenames,
- ) -> Result<(), ErrorReported> {
+ ) -> Result<(), ErrorGuaranteed> {
use rustc_codegen_ssa::back::link::link_binary;
link_binary::<crate::archive::ArArchiveBuilder<'_>>(sess, &codegen_results, outputs)
flags_builder.set("enable_probestack", "false").unwrap(); // __cranelift_probestack is not provided
let enable_verifier = if backend_config.enable_verifier { "true" } else { "false" };
flags_builder.set("enable_verifier", enable_verifier).unwrap();
+ flags_builder.set("regalloc_checker", enable_verifier).unwrap();
let tls_model = match target_triple.binary_format {
BinaryFormat::Elf => "elf_gd",
flags_builder.set("enable_llvm_abi_extensions", "true").unwrap();
- flags_builder.set("regalloc", &backend_config.regalloc).unwrap();
-
use rustc_session::config::OptLevel;
match sess.opts.optimize {
OptLevel::No => {
let flags = settings::Flags::new(flags_builder);
- let variant = cranelift_codegen::isa::BackendVariant::MachInst;
-
let isa_builder = match sess.opts.cg.target_cpu.as_deref() {
Some("native") => {
- let builder = cranelift_native::builder_with_options(variant, true).unwrap();
+ let builder = cranelift_native::builder_with_options(true).unwrap();
builder
}
Some(value) => {
let mut builder =
- cranelift_codegen::isa::lookup_variant(target_triple.clone(), variant)
- .unwrap_or_else(|err| {
- sess.fatal(&format!("can't compile for {}: {}", target_triple, err));
- });
+ cranelift_codegen::isa::lookup(target_triple.clone()).unwrap_or_else(|err| {
+ sess.fatal(&format!("can't compile for {}: {}", target_triple, err));
+ });
if let Err(_) = builder.enable(value) {
sess.fatal("the specified target cpu isn't currently supported by Cranelift.");
}
}
None => {
let mut builder =
- cranelift_codegen::isa::lookup_variant(target_triple.clone(), variant)
- .unwrap_or_else(|err| {
- sess.fatal(&format!("can't compile for {}: {}", target_triple, err));
- });
+ cranelift_codegen::isa::lookup(target_triple.clone()).unwrap_or_else(|err| {
+ sess.fatal(&format!("can't compile for {}: {}", target_triple, err));
+ });
if target_triple.architecture == target_lexicon::Architecture::X86_64 {
// Don't use "haswell" as the default, as it implies `has_lzcnt`.
// macOS CI is still at Ivy Bridge EP, so `lzcnt` is interpreted as `bsr`.
}
};
- isa_builder.finish(flags)
+ match isa_builder.finish(flags) {
+ Ok(target_isa) => target_isa,
+ Err(err) => sess.fatal(&format!("failed to build TargetIsa: {}", err)),
+ }
}
/// This is the entrypoint for a hot plugged rustc_codegen_cranelift
projects / rust.git / blobdiff