/*
- * TODO: support #[inline] attributes.
- * TODO: support LTO.
+ * TODO(antoyo): support #[inline] attributes.
+ * TODO(antoyo): support LTO.
*
- * TODO: remove the local gccjit LD_LIBRARY_PATH in config.sh.
- * TODO: remove the object dependency.
- * TODO: remove the patches.
+ * TODO(antoyo): remove the patches.
*/
#![feature(rustc_private, decl_macro, associated_type_bounds, never_type, trusted_len)]
#![warn(rust_2018_idioms)]
#![warn(unused_lifetimes)]
-/*extern crate flate2;
-extern crate libc;*/
extern crate rustc_ast;
extern crate rustc_codegen_ssa;
extern crate rustc_data_structures;
extern crate rustc_errors;
-//extern crate rustc_fs_util;
extern crate rustc_hir;
extern crate rustc_metadata;
extern crate rustc_middle;
-extern crate rustc_mir;
extern crate rustc_session;
extern crate rustc_span;
extern crate rustc_symbol_mangling;
extern crate rustc_target;
-extern crate snap;
// This prevents duplicating functions and statics that are already part of the host rustc process.
#[allow(unused_extern_crates)]
mod debuginfo;
mod declare;
mod intrinsic;
-mod mangled_std_symbols;
mod mono_item;
mod type_;
mod type_of;
-mod va_arg;
use std::any::Any;
use std::sync::Arc;
-use gccjit::{Block, Context, FunctionType, OptimizationLevel};
+use gccjit::{Context, OptimizationLevel};
use rustc_ast::expand::allocator::AllocatorKind;
use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen};
use rustc_codegen_ssa::base::codegen_crate;
use rustc_codegen_ssa::traits::{CodegenBackend, ExtraBackendMethods, ModuleBufferMethods, ThinBufferMethods, WriteBackendMethods};
use rustc_data_structures::fx::FxHashMap;
use rustc_errors::{ErrorReported, Handler};
+use rustc_metadata::EncodedMetadata;
use rustc_middle::dep_graph::{WorkProduct, WorkProductId};
-use rustc_middle::middle::cstore::EncodedMetadata;
use rustc_middle::ty::TyCtxt;
-use rustc_session::config::{CrateType, Lto, OptLevel, OutputFilenames};
+use rustc_session::config::{Lto, OptLevel, OutputFilenames};
use rustc_session::Session;
use rustc_span::Symbol;
use rustc_span::fatal_error::FatalError;
-use crate::context::unit_name;
-
pub struct PrintOnPanic<F: Fn() -> String>(pub F);
impl<F: Fn() -> String> Drop for PrintOnPanic<F> {
Ok((codegen_results, work_products))
}
- fn link(&self, sess: &Session, mut codegen_results: CodegenResults, outputs: &OutputFilenames) -> Result<(), ErrorReported> {
+ fn link(&self, sess: &Session, codegen_results: CodegenResults, outputs: &OutputFilenames) -> Result<(), ErrorReported> {
use rustc_codegen_ssa::back::link::link_binary;
- if let Some(symbols) = codegen_results.crate_info.exported_symbols.get_mut(&CrateType::Dylib) {
- // TODO: remove when global initializer work without calling a function at runtime.
- // HACK: since this codegen add some symbols (e.g. __gccGlobalCrateInit) and the UI
- // tests load libstd.so as a dynamic library, and rustc use a version-script to specify
- // the symbols visibility, we add * to export all symbols.
- // It seems other symbols from libstd/libcore are causing some issues here as well.
- symbols.push("*".to_string());
- }
link_binary::<crate::archive::ArArchiveBuilder<'_>>(
sess,
}
}
- fn write_compressed_metadata<'tcx>(&self, tcx: TyCtxt<'tcx>, metadata: &EncodedMetadata, gcc_module: &mut Self::Module) {
- base::write_compressed_metadata(tcx, metadata, gcc_module)
- }
-
- fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, mods: &mut Self::Module, kind: AllocatorKind, has_alloc_error_handler: bool) {
- unsafe { allocator::codegen(tcx, mods, kind, has_alloc_error_handler) }
+ fn codegen_allocator<'tcx>(&self, tcx: TyCtxt<'tcx>, mods: &mut Self::Module, module_name: &str, kind: AllocatorKind, has_alloc_error_handler: bool) {
+ unsafe { allocator::codegen(tcx, mods, module_name, kind, has_alloc_error_handler) }
}
fn compile_codegen_unit<'tcx>(&self, tcx: TyCtxt<'tcx>, cgu_name: Symbol) -> (ModuleCodegen<Self::Module>, u64) {
}
fn target_machine_factory(&self, _sess: &Session, _opt_level: OptLevel) -> TargetMachineFactoryFn<Self> {
- // TODO: set opt level.
+ // TODO(antoyo): set opt level.
Arc::new(|_| {
Ok(())
})
fn tune_cpu<'b>(&self, _sess: &'b Session) -> Option<&'b str> {
None
- // TODO
- //llvm_util::tune_cpu(sess)
+ // TODO(antoyo)
}
}
}
unsafe impl Send for GccContext {}
-// FIXME: that shouldn't be Sync. Parallel compilation is currently disabled with "-Zno-parallel-llvm". Try to disable it here.
+// FIXME(antoyo): that shouldn't be Sync. Parallel compilation is currently disabled with "-Zno-parallel-llvm". Try to disable it here.
unsafe impl Sync for GccContext {}
impl WriteBackendMethods for GccCodegenBackend {
type ThinBuffer = ThinBuffer;
fn run_fat_lto(_cgcx: &CodegenContext<Self>, mut modules: Vec<FatLTOInput<Self>>, _cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>) -> Result<LtoModuleCodegen<Self>, FatalError> {
- // TODO: implement LTO by sending -flto to libgccjit and adding the appropriate gcc linker plugins.
+ // TODO(antoyo): implement LTO by sending -flto to libgccjit and adding the appropriate gcc linker plugins.
// NOTE: implemented elsewhere.
+ // TODO: what is implemented elsewhere ^ ?
let module =
match modules.remove(0) {
FatLTOInput::InMemory(module) => module,
FatLTOInput::Serialized { .. } => {
unimplemented!();
- /*info!("pushing serialized module {:?}", name);
- let buffer = SerializedModule::Local(buffer);
- serialized_modules.push((buffer, CString::new(name).unwrap()));*/
}
};
Ok(LtoModuleCodegen::Fat { module: Some(module), _serialized_bitcode: vec![] })
}
unsafe fn optimize(_cgcx: &CodegenContext<Self>, _diag_handler: &Handler, module: &ModuleCodegen<Self::Module>, config: &ModuleConfig) -> Result<(), FatalError> {
- //if cgcx.lto == Lto::Fat {
- //module.module_llvm.context.add_driver_option("-flto");
- //}
module.module_llvm.context.set_optimization_level(to_gcc_opt_level(config.opt_level));
Ok(())
}
}
fn run_lto_pass_manager(_cgcx: &CodegenContext<Self>, _module: &ModuleCodegen<Self::Module>, _config: &ModuleConfig, _thin: bool) -> Result<(), FatalError> {
- // TODO
+ // TODO(antoyo)
Ok(())
}
}
}
-/*fn target_triple(sess: &Session) -> target_lexicon::Triple {
- sess.target.llvm_target.parse().unwrap()
-}*/
-
/// This is the entrypoint for a hot plugged rustc_codegen_gccjit
#[no_mangle]
pub fn __rustc_codegen_backend() -> Box<dyn CodegenBackend> {
}
}
-fn create_function_calling_initializers<'gcc, 'tcx>(tcx: TyCtxt<'tcx>, context: &Context<'gcc>, block: Block<'gcc>) {
- let codegen_units = tcx.collect_and_partition_mono_items(()).1;
- for codegen_unit in codegen_units {
- let codegen_init_func = context.new_function(None, FunctionType::Extern, context.new_type::<()>(), &[],
- &format!("__gccGlobalInit{}", unit_name(&codegen_unit)), false);
- block.add_eval(None, context.new_call(None, codegen_init_func, &[]));
- }
-}
-
fn handle_native(name: &str) -> &str {
if name != "native" {
return name;
}
unimplemented!();
- /*unsafe {
- let mut len = 0;
- let ptr = llvm::LLVMRustGetHostCPUName(&mut len);
- str::from_utf8(slice::from_raw_parts(ptr as *const u8, len)).unwrap()
- }*/
}
pub fn target_cpu(sess: &Session) -> &str {
},
)
.filter(|_feature| {
- /*if feature.starts_with("sse") {
- return true;
- }*/
- // TODO: implement a way to get enabled feature in libgccjit.
- //println!("Feature: {}", feature);
- /*let llvm_feature = to_llvm_feature(sess, feature);
- let cstr = CString::new(llvm_feature).unwrap();
- unsafe { llvm::LLVMRustHasFeature(target_machine, cstr.as_ptr()) }*/
+ // TODO(antoyo): implement a way to get enabled feature in libgccjit.
false
})
.map(|feature| Symbol::intern(feature))
projects / rust.git / blobdiff