-#![feature(rustc_private, decl_macro, never_type, hash_drain_filter, vec_into_raw_parts)]
+#![feature(rustc_private, decl_macro)]
+#![cfg_attr(feature = "jit", feature(never_type, vec_into_raw_parts, once_cell))]
#![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_hir;
extern crate rustc_incremental;
extern crate rustc_index;
+extern crate rustc_interface;
+extern crate rustc_metadata;
extern crate rustc_session;
extern crate rustc_span;
extern crate rustc_target;
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, MetadataLoader};
-use rustc_middle::ty::query::Providers;
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 allocator;
mod analyze;
mod archive;
-mod backend;
mod base;
mod cast;
mod codegen_i128;
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;
+ 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::mir::{self, *};
- pub(crate) use rustc_middle::ty::layout::{self, TyAndLayout};
+ 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,
};
- pub(crate) use rustc_target::abi::{Abi, LayoutOf, Scalar, Size, VariantIdx};
+ pub(crate) use rustc_target::abi::{Abi, Scalar, Size, VariantIdx};
pub(crate) use rustc_data_structures::fx::FxHashMap;
pub(crate) use cranelift_codegen::isa::{self, CallConv};
pub(crate) use cranelift_codegen::Context;
pub(crate) use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext, Variable};
- pub(crate) use cranelift_module::{self, DataContext, DataId, FuncId, Linkage, Module};
+ pub(crate) use cranelift_module::{self, DataContext, FuncId, Linkage, Module};
pub(crate) use crate::abi::*;
pub(crate) use crate::base::{codegen_operand, codegen_place};
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));
+ UnwindContext::new(isa, matches!(backend_config.codegen_mode, CodegenMode::Aot));
let debug_context = if debug_info { 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 metadata_loader(&self) -> Box<dyn MetadataLoader + Sync> {
- Box::new(rustc_codegen_ssa::back::metadata::DefaultMetadataLoader)
- }
-
- fn provide(&self, _providers: &mut Providers) {}
- fn provide_extern(&self, _providers: &mut Providers) {}
-
fn target_features(&self, _sess: &Session) -> Vec<rustc_span::Symbol> {
vec![]
}
+ fn print_version(&self) {
+ println!("Cranelift version: {}", cranelift_codegen::VERSION);
+ }
+
fn codegen_crate(
&self,
tcx: TyCtxt<'_>,
let config = if let Some(config) = self.config.clone() {
config
} else {
+ if !tcx.sess.unstable_options() && !tcx.sess.opts.cg.llvm_args.is_empty() {
+ tcx.sess.fatal("`-Z unstable-options` must be passed to allow configuring cg_clif");
+ }
BackendConfig::from_opts(&tcx.sess.opts.cg.llvm_args)
.unwrap_or_else(|err| tcx.sess.fatal(&err))
};
&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;
- let target_cpu = crate::target_triple(sess).to_string();
- link_binary::<crate::archive::ArArchiveBuilder<'_>>(
- sess,
- &codegen_results,
- outputs,
- &codegen_results.crate_name.as_str(),
- &target_cpu,
- );
-
- Ok(())
+ link_binary::<crate::archive::ArArchiveBuilder<'_>>(sess, &codegen_results, outputs)
}
}
fn target_triple(sess: &Session) -> target_lexicon::Triple {
- sess.target.llvm_target.parse().unwrap()
+ match sess.target.llvm_target.parse() {
+ Ok(triple) => triple,
+ Err(err) => sess.fatal(&format!("target not recognized: {}", err)),
+ }
}
fn build_isa(sess: &Session, backend_config: &BackendConfig) -> Box<dyn isa::TargetIsa + 'static> {
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, variant).unwrap();
+ let mut builder =
+ 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.");
+ sess.fatal("the specified target cpu isn't currently supported by Cranelift.");
}
builder
}
None => {
- let mut builder = cranelift_codegen::isa::lookup_variant(target_triple, variant).unwrap();
- // 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`.
- builder.enable("nehalem").unwrap();
+ let mut builder =
+ 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`.
+ builder.enable("nehalem").unwrap();
+ }
builder
}
};
-
- 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