use rustc_data_structures::fx::FxHashMap;
use rustc_codegen_utils::symbol_export;
use time_graph::Timeline;
-use {ModuleCodegen, ModuleLlvm, ModuleKind};
+use ModuleLlvm;
+use rustc_codegen_utils::{ModuleCodegen, ModuleKind};
use libc;
use time_graph::{self, TimeGraph, Timeline};
use llvm::{self, DiagnosticInfo, PassManager, SMDiagnostic};
use llvm_util;
-use {CodegenResults, ModuleCodegen, CompiledModule, ModuleKind, ModuleLlvm,
- CachedModuleCodegen};
+use {CodegenResults, ModuleLlvm};
+use rustc_codegen_utils::{ModuleCodegen, ModuleKind, CachedModuleCodegen, CompiledModule};
use CrateInfo;
use rustc::hir::def_id::{CrateNum, LOCAL_CRATE};
use rustc::ty::TyCtxt;
//! int) and rec(x=int, y=int, z=int) will have the same llvm::Type.
use super::ModuleLlvm;
-use super::ModuleCodegen;
-use super::ModuleKind;
-use super::CachedModuleCodegen;
+use rustc_codegen_utils::{ModuleCodegen, ModuleKind, CachedModuleCodegen};
use super::LlvmCodegenBackend;
use abi;
Visibility::Protected => llvm::Visibility::Protected,
}
}
-
-// FIXME(mw): Anything that is produced via DepGraph::with_task() must implement
-// the HashStable trait. Normally DepGraph::with_task() calls are
-// hidden behind queries, but CGU creation is a special case in two
-// ways: (1) it's not a query and (2) CGU are output nodes, so their
-// Fingerprints are not actually needed. It remains to be clarified
-// how exactly this case will be handled in the red/green system but
-// for now we content ourselves with providing a no-op HashStable
-// implementation for CGUs.
-mod temp_stable_hash_impls {
- use rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher,
- HashStable};
- use {ModuleCodegen, ModuleLlvm};
-
- impl<HCX> HashStable<HCX> for ModuleCodegen<ModuleLlvm> {
- fn hash_stable<W: StableHasherResult>(&self,
- _: &mut HCX,
- _: &mut StableHasher<W>) {
- // do nothing
- }
- }
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use super::HasCodegen;
use mir::place::PlaceRef;
use rustc::hir::{GlobalAsm, InlineAsm};
+++ /dev/null
-// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-use rustc::ty::layout::{HasTyCtxt, LayoutOf, TyLayout};
-use rustc::ty::Ty;
-
-use super::CodegenObject;
-use rustc::middle::allocator::AllocatorKind;
-use rustc::middle::cstore::EncodedMetadata;
-use rustc::mir::mono::Stats;
-use rustc::session::Session;
-use rustc::ty::TyCtxt;
-use std::any::Any;
-use std::sync::mpsc::Receiver;
-use syntax_pos::symbol::InternedString;
-use time_graph::TimeGraph;
-use ModuleCodegen;
-
-pub trait BackendTypes {
- type Value: CodegenObject;
- type BasicBlock: Copy;
- type Type: CodegenObject;
- type Context;
- type Funclet;
-
- type DIScope: Copy;
-}
-
-pub trait Backend<'tcx>:
- BackendTypes + HasTyCtxt<'tcx> + LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>>
-{
-}
-
-impl<'tcx, T> Backend<'tcx> for T where
- Self: BackendTypes + HasTyCtxt<'tcx> + LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>>
-{}
-
-pub trait BackendMethods {
- type Module;
- type OngoingCodegen;
-
- fn new_metadata(&self, sess: &Session, mod_name: &str) -> Self::Module;
- fn write_metadata<'b, 'gcx>(
- &self,
- tcx: TyCtxt<'b, 'gcx, 'gcx>,
- metadata: &Self::Module,
- ) -> EncodedMetadata;
- fn codegen_allocator(&self, tcx: TyCtxt, mods: &Self::Module, kind: AllocatorKind);
-
- fn start_async_codegen(
- &self,
- tcx: TyCtxt,
- time_graph: Option<TimeGraph>,
- metadata: EncodedMetadata,
- coordinator_receive: Receiver<Box<dyn Any + Send>>,
- total_cgus: usize,
- ) -> Self::OngoingCodegen;
- fn submit_pre_codegened_module_to_llvm(
- &self,
- codegen: &Self::OngoingCodegen,
- tcx: TyCtxt,
- module: ModuleCodegen<Self::Module>,
- );
- fn codegen_aborted(codegen: Self::OngoingCodegen);
- fn codegen_finished(&self, codegen: &Self::OngoingCodegen, tcx: TyCtxt);
- fn check_for_errors(&self, codegen: &Self::OngoingCodegen, sess: &Session);
- fn wait_for_signal_to_codegen_item(&self, codegen: &Self::OngoingCodegen);
- fn compile_codegen_unit<'a, 'tcx: 'a>(
- &self,
- tcx: TyCtxt<'a, 'tcx, 'tcx>,
- cgu_name: InternedString,
- ) -> Stats;
-}
fn set_cleanup(&self, landing_pad: Self::Value);
fn resume(&self, exn: Self::Value) -> Self::Value;
fn cleanup_pad(&self, parent: Option<Self::Value>, args: &[Self::Value]) -> Self::Funclet;
- fn cleanup_ret(&self, funclet: &Self::Funclet, unwind: Option<Self::BasicBlock>) -> Self::Value;
+ fn cleanup_ret(&self, funclet: &Self::Funclet, unwind: Option<Self::BasicBlock>)
+ -> Self::Value;
fn catch_pad(&self, parent: Self::Value, args: &[Self::Value]) -> Self::Funclet;
fn catch_ret(&self, funclet: &Self::Funclet, unwind: Self::BasicBlock) -> Self::Value;
fn catch_switch(
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use super::HasCodegen;
use debuginfo::{FunctionDebugContext, MirDebugScope, VariableAccess, VariableKind};
use monomorphize::Instance;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use monomorphize::Instance;
use rustc::hir::def_id::DefId;
use rustc::mir::mono::{Linkage, Visibility};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use super::HasCodegen;
use abi::FnType;
use mir::operand::OperandRef;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use libc::c_uint;
use monomorphize::partitioning::CodegenUnit;
use rustc::mir::mono::Stats;
mod abi;
mod asm;
-mod backend;
mod builder;
mod consts;
mod debuginfo;
pub use self::abi::{AbiBuilderMethods, AbiMethods};
pub use self::asm::{AsmBuilderMethods, AsmMethods};
-pub use self::backend::{Backend, BackendMethods, BackendTypes};
pub use self::builder::BuilderMethods;
pub use self::consts::ConstMethods;
pub use self::debuginfo::{DebugInfoBuilderMethods, DebugInfoMethods};
pub use self::type_::{
ArgTypeMethods, BaseTypeMethods, DerivedTypeMethods, LayoutTypeMethods, TypeMethods,
};
-
-use std::fmt;
+pub use rustc_codegen_utils::interfaces::{Backend, BackendMethods, BackendTypes, CodegenObject};
pub trait CodegenMethods<'tcx>:
Backend<'tcx>
DIScope = Self::DIScope,
>;
}
-
-pub trait CodegenObject: Copy + PartialEq + fmt::Debug {}
-impl<T: Copy + PartialEq + fmt::Debug> CodegenObject for T {}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use rustc::hir::def_id::DefId;
use rustc::ty::layout::Align;
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use super::backend::Backend;
+use super::Backend;
use super::HasCodegen;
use mir::place::PlaceRef;
use rustc::ty::layout::TyLayout;
#![feature(static_nobundle)]
use back::write::create_target_machine;
-use rustc::dep_graph::WorkProduct;
use syntax_pos::symbol::Symbol;
#[macro_use] extern crate bitflags;
extern crate tempfile;
extern crate memmap;
-use back::bytecode::RLIB_BYTECODE_EXTENSION;
use interfaces::*;
use time_graph::TimeGraph;
use std::sync::mpsc::Receiver;
use rustc::util::nodemap::{FxHashSet, FxHashMap};
use rustc::util::profiling::ProfileCategory;
use rustc_mir::monomorphize;
-use rustc_codegen_utils::{CompiledModule, ModuleKind};
+use rustc_codegen_utils::{ModuleCodegen, CompiledModule};
use rustc_codegen_utils::codegen_backend::CodegenBackend;
use rustc_data_structures::svh::Svh;
LlvmCodegenBackend::new()
}
-pub struct ModuleCodegen<M> {
- /// The name of the module. When the crate may be saved between
- /// compilations, incremental compilation requires that name be
- /// unique amongst **all** crates. Therefore, it should contain
- /// something unique to this crate (e.g., a module path) as well
- /// as the crate name and disambiguator.
- /// We currently generate these names via CodegenUnit::build_cgu_name().
- name: String,
- module_llvm: M,
- kind: ModuleKind,
-}
-
-struct CachedModuleCodegen {
- name: String,
- source: WorkProduct,
-}
-
-impl ModuleCodegen<ModuleLlvm> {
- fn into_compiled_module(self,
- emit_obj: bool,
- emit_bc: bool,
- emit_bc_compressed: bool,
- outputs: &OutputFilenames) -> CompiledModule {
- let object = if emit_obj {
- Some(outputs.temp_path(OutputType::Object, Some(&self.name)))
- } else {
- None
- };
- let bytecode = if emit_bc {
- Some(outputs.temp_path(OutputType::Bitcode, Some(&self.name)))
- } else {
- None
- };
- let bytecode_compressed = if emit_bc_compressed {
- Some(outputs.temp_path(OutputType::Bitcode, Some(&self.name))
- .with_extension(RLIB_BYTECODE_EXTENSION))
- } else {
- None
- };
-
- CompiledModule {
- name: self.name.clone(),
- kind: self.kind,
- object,
- bytecode,
- bytecode_compressed,
- }
- }
-}
-
pub struct ModuleLlvm {
llcx: &'static mut llvm::Context,
llmod_raw: *const llvm::Module,
X86_MMX,
Token,
}
+
+// FIXME(mw): Anything that is produced via DepGraph::with_task() must implement
+// the HashStable trait. Normally DepGraph::with_task() calls are
+// hidden behind queries, but CGU creation is a special case in two
+// ways: (1) it's not a query and (2) CGU are output nodes, so their
+// Fingerprints are not actually needed. It remains to be clarified
+// how exactly this case will be handled in the red/green system but
+// for now we content ourselves with providing a no-op HashStable
+// implementation for CGUs.
+mod temp_stable_hash_impls {
+ use rustc_data_structures::stable_hasher::{StableHasherResult, StableHasher,
+ HashStable};
+ use ModuleCodegen;
+
+ impl<HCX, M> HashStable<HCX> for ModuleCodegen<M> {
+ fn hash_stable<W: StableHasherResult>(&self,
+ _: &mut HCX,
+ _: &mut StableHasher<W>) {
+ // do nothing
+ }
+ }
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use rustc::ty::layout::{HasTyCtxt, LayoutOf, TyLayout};
+use rustc::ty::Ty;
+
+use super::CodegenObject;
+use rustc::middle::allocator::AllocatorKind;
+use rustc::middle::cstore::EncodedMetadata;
+use rustc::mir::mono::Stats;
+use rustc::session::Session;
+use rustc::ty::TyCtxt;
+use rustc::util::time_graph::TimeGraph;
+use std::any::Any;
+use std::sync::mpsc::Receiver;
+use syntax_pos::symbol::InternedString;
+use ModuleCodegen;
+
+pub trait BackendTypes {
+ type Value: CodegenObject;
+ type BasicBlock: Copy;
+ type Type: CodegenObject;
+ type Context;
+ type Funclet;
+
+ type DIScope: Copy;
+}
+
+pub trait Backend<'tcx>:
+ BackendTypes + HasTyCtxt<'tcx> + LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>>
+{
+}
+
+impl<'tcx, T> Backend<'tcx> for T where
+ Self: BackendTypes + HasTyCtxt<'tcx> + LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>>
+{}
+
+pub trait BackendMethods {
+ type Module;
+ type OngoingCodegen;
+
+ fn new_metadata(&self, sess: &Session, mod_name: &str) -> Self::Module;
+ fn write_metadata<'b, 'gcx>(
+ &self,
+ tcx: TyCtxt<'b, 'gcx, 'gcx>,
+ metadata: &Self::Module,
+ ) -> EncodedMetadata;
+ fn codegen_allocator(&self, tcx: TyCtxt, mods: &Self::Module, kind: AllocatorKind);
+
+ fn start_async_codegen(
+ &self,
+ tcx: TyCtxt,
+ time_graph: Option<TimeGraph>,
+ metadata: EncodedMetadata,
+ coordinator_receive: Receiver<Box<dyn Any + Send>>,
+ total_cgus: usize,
+ ) -> Self::OngoingCodegen;
+ fn submit_pre_codegened_module_to_llvm(
+ &self,
+ codegen: &Self::OngoingCodegen,
+ tcx: TyCtxt,
+ module: ModuleCodegen<Self::Module>,
+ );
+ fn codegen_aborted(codegen: Self::OngoingCodegen);
+ fn codegen_finished(&self, codegen: &Self::OngoingCodegen, tcx: TyCtxt);
+ fn check_for_errors(&self, codegen: &Self::OngoingCodegen, sess: &Session);
+ fn wait_for_signal_to_codegen_item(&self, codegen: &Self::OngoingCodegen);
+ fn compile_codegen_unit<'a, 'tcx: 'a>(
+ &self,
+ tcx: TyCtxt<'a, 'tcx, 'tcx>,
+ cgu_name: InternedString,
+ ) -> Stats;
+}
--- /dev/null
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+mod backend;
+
+pub use self::backend::{Backend, BackendMethods, BackendTypes};
+
+use std::fmt;
+
+pub trait CodegenObject: Copy + PartialEq + fmt::Debug {}
+impl<T: Copy + PartialEq + fmt::Debug> CodegenObject for T {}
#![feature(custom_attribute)]
#![feature(nll)]
#![allow(unused_attributes)]
+#![allow(dead_code)]
#![feature(quote)]
#![feature(rustc_diagnostic_macros)]
use rustc::session::Session;
use rustc::ty::TyCtxt;
+use rustc::dep_graph::WorkProduct;
+use rustc::session::config::{OutputFilenames, OutputType};
pub mod command;
+pub mod interfaces;
pub mod link;
pub mod linker;
pub mod codegen_backend;
pub mod symbol_names_test;
pub mod common;
-/// check for the #[rustc_error] annotation, which forces an
-/// error in codegen. This is used to write compile-fail tests
-/// that actually test that compilation succeeds without
-/// reporting an error.
-pub fn check_for_rustc_errors_attr(tcx: TyCtxt) {
- if let Some((id, span, _)) = *tcx.sess.entry_fn.borrow() {
- let main_def_id = tcx.hir.local_def_id(id);
+pub struct ModuleCodegen<M> {
+ /// The name of the module. When the crate may be saved between
+ /// compilations, incremental compilation requires that name be
+ /// unique amongst **all** crates. Therefore, it should contain
+ /// something unique to this crate (e.g., a module path) as well
+ /// as the crate name and disambiguator.
+ /// We currently generate these names via CodegenUnit::build_cgu_name().
+ pub name: String,
+ pub module_llvm: M,
+ pub kind: ModuleKind,
+}
- if tcx.has_attr(main_def_id, "rustc_error") {
- tcx.sess.span_fatal(span, "compilation successful");
+pub const RLIB_BYTECODE_EXTENSION: &str = "bc.z";
+
+impl<M> ModuleCodegen<M> {
+ pub fn into_compiled_module(self,
+ emit_obj: bool,
+ emit_bc: bool,
+ emit_bc_compressed: bool,
+ outputs: &OutputFilenames) -> CompiledModule {
+ let object = if emit_obj {
+ Some(outputs.temp_path(OutputType::Object, Some(&self.name)))
+ } else {
+ None
+ };
+ let bytecode = if emit_bc {
+ Some(outputs.temp_path(OutputType::Bitcode, Some(&self.name)))
+ } else {
+ None
+ };
+ let bytecode_compressed = if emit_bc_compressed {
+ Some(outputs.temp_path(OutputType::Bitcode, Some(&self.name))
+ .with_extension(RLIB_BYTECODE_EXTENSION))
+ } else {
+ None
+ };
+
+ CompiledModule {
+ name: self.name.clone(),
+ kind: self.kind,
+ object,
+ bytecode,
+ bytecode_compressed,
}
}
}
-#[derive(Copy, Clone, Debug, PartialEq)]
-pub enum ModuleKind {
- Regular,
- Metadata,
- Allocator,
-}
-
#[derive(Debug)]
pub struct CompiledModule {
pub name: String,
pub bytecode_compressed: Option<PathBuf>,
}
+pub struct CachedModuleCodegen {
+ pub name: String,
+ pub source: WorkProduct,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ModuleKind {
+ Regular,
+ Metadata,
+ Allocator,
+}
+
+/// check for the #[rustc_error] annotation, which forces an
+/// error in codegen. This is used to write compile-fail tests
+/// that actually test that compilation succeeds without
+/// reporting an error.
+pub fn check_for_rustc_errors_attr(tcx: TyCtxt) {
+ if let Some((id, span, _)) = *tcx.sess.entry_fn.borrow() {
+ let main_def_id = tcx.hir.local_def_id(id);
+
+ if tcx.has_attr(main_def_id, "rustc_error") {
+ tcx.sess.span_fatal(span, "compilation successful");
+ }
+ }
+}
+
pub fn find_library(name: &str, search_paths: &[PathBuf], sess: &Session)
-> PathBuf {
// On Windows, static libraries sometimes show up as libfoo.a and other
projects / rust.git / commitdiff