mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use standard Rust capitalization rules for names containing "LTO".

Browse Source
This commit is contained in:
Nicholas Nethercote 2023-07-21 11:18:25 +10:00
parent a08220bcab
commit 3b44f5b0eb
5 changed files with 22 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
compiler/rustc_codegen_gcc/src/lib.rs
View File

@ -71,7 +71,7 @@
use rustc_ast::expand::allocator::AllocatorKind; use rustc_ast::expand::allocator::AllocatorKind;
use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen}; use rustc_codegen_ssa::{CodegenResults, CompiledModule, ModuleCodegen};
use rustc_codegen_ssa::base::codegen_crate; use rustc_codegen_ssa::base::codegen_crate;
use rustc_codegen_ssa::back::write::{CodegenContext, FatLTOInput, ModuleConfig, TargetMachineFactoryFn}; use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput, ModuleConfig, TargetMachineFactoryFn};
use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule}; use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
use rustc_codegen_ssa::target_features::supported_target_features; use rustc_codegen_ssa::target_features::supported_target_features;
use rustc_codegen_ssa::traits::{CodegenBackend, ExtraBackendMethods, ModuleBufferMethods, ThinBufferMethods, WriteBackendMethods}; use rustc_codegen_ssa::traits::{CodegenBackend, ExtraBackendMethods, ModuleBufferMethods, ThinBufferMethods, WriteBackendMethods};
@ -217,14 +217,14 @@ impl WriteBackendMethods for GccCodegenBackend {
type ThinData = (); type ThinData = ();
type ThinBuffer = ThinBuffer; 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> { fn run_fat_lto(_cgcx: &CodegenContext<Self>, mut modules: Vec<FatLtoInput<Self>>, _cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>) -> Result<LtoModuleCodegen<Self>, FatalError> {
// TODO(antoyo): 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. // NOTE: implemented elsewhere.
// TODO(antoyo): what is implemented elsewhere ^ ? // TODO(antoyo): what is implemented elsewhere ^ ?
let module = let module =
match modules.remove(0) { match modules.remove(0) {
FatLTOInput::InMemory(module) => module, FatLtoInput::InMemory(module) => module,
FatLTOInput::Serialized { .. } => { FatLtoInput::Serialized { .. } => {
unimplemented!(); unimplemented!();
} }
}; };

10
compiler/rustc_codegen_llvm/src/back/lto.rs
View File

@ -7,7 +7,7 @@
use object::read::archive::ArchiveFile; use object::read::archive::ArchiveFile;
use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule, ThinShared}; use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule, ThinShared};
use rustc_codegen_ssa::back::symbol_export; use rustc_codegen_ssa::back::symbol_export;
use rustc_codegen_ssa::back::write::{CodegenContext, FatLTOInput, TargetMachineFactoryConfig}; use rustc_codegen_ssa::back::write::{CodegenContext, FatLtoInput, TargetMachineFactoryConfig};
use rustc_codegen_ssa::traits::*; use rustc_codegen_ssa::traits::*;
use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind}; use rustc_codegen_ssa::{looks_like_rust_object_file, ModuleCodegen, ModuleKind};
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
@ -166,7 +166,7 @@ fn get_bitcode_slice_from_object_data(obj: &[u8]) -> Result<&[u8], LtoBitcodeFro
/// for further optimization. /// for further optimization.
pub(crate) fn run_fat( pub(crate) fn run_fat(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
modules: Vec<FatLTOInput<LlvmCodegenBackend>>, modules: Vec<FatLtoInput<LlvmCodegenBackend>>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> { ) -> Result<LtoModuleCodegen<LlvmCodegenBackend>, FatalError> {
let diag_handler = cgcx.create_diag_handler(); let diag_handler = cgcx.create_diag_handler();
@ -220,7 +220,7 @@ pub(crate) fn prepare_thin(module: ModuleCodegen<ModuleLlvm>) -> (String, ThinBu
fn fat_lto( fn fat_lto(
cgcx: &CodegenContext<LlvmCodegenBackend>, cgcx: &CodegenContext<LlvmCodegenBackend>,
diag_handler: &Handler, diag_handler: &Handler,
modules: Vec<FatLTOInput<LlvmCodegenBackend>>, modules: Vec<FatLtoInput<LlvmCodegenBackend>>,
cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<ModuleBuffer>, WorkProduct)>,
mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>, mut serialized_modules: Vec<(SerializedModule<ModuleBuffer>, CString)>,
symbols_below_threshold: &[*const libc::c_char], symbols_below_threshold: &[*const libc::c_char],
@ -245,8 +245,8 @@ fn fat_lto(
})); }));
for module in modules { for module in modules {
match module { match module {
FatLTOInput::InMemory(m) => in_memory.push(m), FatLtoInput::InMemory(m) => in_memory.push(m),
FatLTOInput::Serialized { name, buffer } => { FatLtoInput::Serialized { name, buffer } => {
info!("pushing serialized module {:?}", name); info!("pushing serialized module {:?}", name);
let buffer = SerializedModule::Local(buffer); let buffer = SerializedModule::Local(buffer);
serialized_modules.push((buffer, CString::new(name).unwrap())); serialized_modules.push((buffer, CString::new(name).unwrap()));

4
compiler/rustc_codegen_llvm/src/lib.rs
View File

@ -28,7 +28,7 @@
use rustc_ast::expand::allocator::AllocatorKind; use rustc_ast::expand::allocator::AllocatorKind;
use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule}; use rustc_codegen_ssa::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
use rustc_codegen_ssa::back::write::{ use rustc_codegen_ssa::back::write::{
CodegenContext, FatLTOInput, ModuleConfig, TargetMachineFactoryConfig, TargetMachineFactoryFn, CodegenContext, FatLtoInput, ModuleConfig, TargetMachineFactoryConfig, TargetMachineFactoryFn,
}; };
use rustc_codegen_ssa::traits::*; use rustc_codegen_ssa::traits::*;
use rustc_codegen_ssa::ModuleCodegen; use rustc_codegen_ssa::ModuleCodegen;
@ -200,7 +200,7 @@ fn run_link(
} }
fn run_fat_lto( fn run_fat_lto(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
modules: Vec<FatLTOInput<Self>>, modules: Vec<FatLtoInput<Self>>,
cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
) -> Result<LtoModuleCodegen<Self>, FatalError> { ) -> Result<LtoModuleCodegen<Self>, FatalError> {
back::lto::run_fat(cgcx, modules, cached_modules) back::lto::run_fat(cgcx, modules, cached_modules)

18
compiler/rustc_codegen_ssa/src/back/write.rs
View File

@ -374,7 +374,7 @@ pub fn config(&self, kind: ModuleKind) -> &ModuleConfig {
fn generate_lto_work<B: ExtraBackendMethods>( fn generate_lto_work<B: ExtraBackendMethods>(
cgcx: &CodegenContext<B>, cgcx: &CodegenContext<B>,
needs_fat_lto: Vec<FatLTOInput<B>>, needs_fat_lto: Vec<FatLtoInput<B>>,
needs_thin_lto: Vec<(String, B::ThinBuffer)>, needs_thin_lto: Vec<(String, B::ThinBuffer)>,
import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>, import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
) -> Vec<(WorkItem<B>, u64)> { ) -> Vec<(WorkItem<B>, u64)> {
@ -758,14 +758,14 @@ pub(crate) enum WorkItemResult<B: WriteBackendMethods> {
/// The backend has finished compiling a CGU, which now needs to go through /// The backend has finished compiling a CGU, which now needs to go through
/// fat LTO. /// fat LTO.
NeedsFatLTO(FatLTOInput<B>), NeedsFatLto(FatLtoInput<B>),
/// The backend has finished compiling a CGU, which now needs to go through /// The backend has finished compiling a CGU, which now needs to go through
/// thin LTO. /// thin LTO.
NeedsThinLTO(String, B::ThinBuffer), NeedsThinLto(String, B::ThinBuffer),
} }
pub enum FatLTOInput<B: WriteBackendMethods> { pub enum FatLtoInput<B: WriteBackendMethods> {
Serialized { name: String, buffer: B::ModuleBuffer }, Serialized { name: String, buffer: B::ModuleBuffer },
InMemory(ModuleCodegen<B::Module>), InMemory(ModuleCodegen<B::Module>),
} }
@ -854,7 +854,7 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e); panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);
}); });
} }
Ok(WorkItemResult::NeedsThinLTO(name, thin_buffer)) Ok(WorkItemResult::NeedsThinLto(name, thin_buffer))
} }
ComputedLtoType::Fat => match bitcode { ComputedLtoType::Fat => match bitcode {
Some(path) => { Some(path) => {
@ -862,9 +862,9 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
fs::write(&path, buffer.data()).unwrap_or_else(|e| { fs::write(&path, buffer.data()).unwrap_or_else(|e| {
panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e); panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);
}); });
Ok(WorkItemResult::NeedsFatLTO(FatLTOInput::Serialized { name, buffer })) Ok(WorkItemResult::NeedsFatLto(FatLtoInput::Serialized { name, buffer }))
} }
None => Ok(WorkItemResult::NeedsFatLTO(FatLTOInput::InMemory(module))), None => Ok(WorkItemResult::NeedsFatLto(FatLtoInput::InMemory(module))),
}, },
} }
} }
@ -1554,12 +1554,12 @@ enum CodegenState {
assert!(compiled_modules.is_empty()); assert!(compiled_modules.is_empty());
needs_link.push(module); needs_link.push(module);
} }
Ok(WorkItemResult::NeedsFatLTO(fat_lto_input)) => { Ok(WorkItemResult::NeedsFatLto(fat_lto_input)) => {
assert!(!started_lto); assert!(!started_lto);
assert!(needs_thin_lto.is_empty()); assert!(needs_thin_lto.is_empty());
needs_fat_lto.push(fat_lto_input); needs_fat_lto.push(fat_lto_input);
} }
Ok(WorkItemResult::NeedsThinLTO(name, thin_buffer)) => { Ok(WorkItemResult::NeedsThinLto(name, thin_buffer)) => {
assert!(!started_lto); assert!(!started_lto);
assert!(needs_fat_lto.is_empty()); assert!(needs_fat_lto.is_empty());
needs_thin_lto.push((name, thin_buffer)); needs_thin_lto.push((name, thin_buffer));

4
compiler/rustc_codegen_ssa/src/traits/write.rs
View File

@ -1,5 +1,5 @@
use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule}; use crate::back::lto::{LtoModuleCodegen, SerializedModule, ThinModule};
use crate::back::write::{CodegenContext, FatLTOInput, ModuleConfig}; use crate::back::write::{CodegenContext, FatLtoInput, ModuleConfig};
use crate::{CompiledModule, ModuleCodegen}; use crate::{CompiledModule, ModuleCodegen};
use rustc_errors::{FatalError, Handler}; use rustc_errors::{FatalError, Handler};
@ -23,7 +23,7 @@ fn run_link(
/// for further optimization. /// for further optimization.
fn run_fat_lto( fn run_fat_lto(
cgcx: &CodegenContext<Self>, cgcx: &CodegenContext<Self>,
modules: Vec<FatLTOInput<Self>>, modules: Vec<FatLtoInput<Self>>,
cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>, cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>,
) -> Result<LtoModuleCodegen<Self>, FatalError>; ) -> Result<LtoModuleCodegen<Self>, FatalError>;
/// Performs thin LTO by performing necessary global analysis and returning two /// Performs thin LTO by performing necessary global analysis and returning two