rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Directly raise fatal errors inside the codegen backends

Browse Source 
As opposed to passing it around through Result.
This commit is contained in:
bjorn3
2025-08-24 10:47:04 +00:00
parent 46a7d28a7d
commit 525c6a3562
8 changed files with 117 additions and 124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -15,8 +15,8 @@ use rustc_data_structures::profiling::{SelfProfilerRef, VerboseTimingGuard};
use rustc_errors::emitter::Emitter;
use rustc_errors::translation::Translator;
use rustc_errors::{
Diag, DiagArgMap, DiagCtxt, DiagMessage, ErrCode, FatalError, FatalErrorMarker, Level,
MultiSpan, Style, Suggestions,
Diag, DiagArgMap, DiagCtxt, DiagMessage, ErrCode, FatalErrorMarker, Level, MultiSpan, Style,
Suggestions,
};
use rustc_fs_util::link_or_copy;
use rustc_incremental::{
@@ -396,8 +396,7 @@ fn generate_thin_lto_work<B: ExtraBackendMethods>(
each_linked_rlib_for_lto,
needs_thin_lto,
import_only_modules,
)
.unwrap_or_else(|e| e.raise());
);
lto_modules
.into_iter()
.map(|module| {
@@ -845,11 +844,11 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
cgcx: &CodegenContext<B>,
mut module: ModuleCodegen<B::Module>,
module_config: &ModuleConfig,
) -> Result<WorkItemResult<B>, FatalError> {
) -> WorkItemResult<B> {
let dcx = cgcx.create_dcx();
let dcx = dcx.handle();
B::optimize(cgcx, dcx, &mut module, module_config)?;
B::optimize(cgcx, dcx, &mut module, module_config);
// After we've done the initial round of optimizations we need to
// decide whether to synchronously codegen this module or ship it
@@ -869,8 +868,8 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
match lto_type {
ComputedLtoType::No => {
let module = B::codegen(cgcx, module, module_config)?;
Ok(WorkItemResult::Finished(module))
let module = B::codegen(cgcx, module, module_config);
WorkItemResult::Finished(module)
}
ComputedLtoType::Thin => {
let (name, thin_buffer) = B::prepare_thin(module, false);
@@ -879,7 +878,7 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);
});
}
Ok(WorkItemResult::NeedsThinLto(name, thin_buffer))
WorkItemResult::NeedsThinLto(name, thin_buffer)
}
ComputedLtoType::Fat => match bitcode {
Some(path) => {
@@ -887,12 +886,12 @@ fn execute_optimize_work_item<B: ExtraBackendMethods>(
fs::write(&path, buffer.data()).unwrap_or_else(|e| {
panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);
});
Ok(WorkItemResult::NeedsFatLto(FatLtoInput::Serialized {
WorkItemResult::NeedsFatLto(FatLtoInput::Serialized {
name,
buffer: SerializedModule::Local(buffer),
}))
})
}
None => Ok(WorkItemResult::NeedsFatLto(FatLtoInput::InMemory(module))),
None => WorkItemResult::NeedsFatLto(FatLtoInput::InMemory(module)),
},
}
}
@@ -988,7 +987,7 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
mut needs_fat_lto: Vec<FatLtoInput<B>>,
import_only_modules: Vec<(SerializedModule<B::ModuleBuffer>, WorkProduct)>,
module_config: &ModuleConfig,
) -> Result<WorkItemResult<B>, FatalError> {
) -> WorkItemResult<B> {
for (module, wp) in import_only_modules {
needs_fat_lto.push(FatLtoInput::Serialized { name: wp.cgu_name, buffer: module })
}
@@ -998,19 +997,19 @@ fn execute_fat_lto_work_item<B: ExtraBackendMethods>(
exported_symbols_for_lto,
each_linked_rlib_for_lto,
needs_fat_lto,
)?;
let module = B::codegen(cgcx, module, module_config)?;
Ok(WorkItemResult::Finished(module))
);
let module = B::codegen(cgcx, module, module_config);
WorkItemResult::Finished(module)
}
fn execute_thin_lto_work_item<B: ExtraBackendMethods>(
cgcx: &CodegenContext<B>,
module: lto::ThinModule<B>,
module_config: &ModuleConfig,
) -> Result<WorkItemResult<B>, FatalError> {
let module = B::optimize_thin(cgcx, module)?;
let module = B::codegen(cgcx, module, module_config)?;
Ok(WorkItemResult::Finished(module))
) -> WorkItemResult<B> {
let module = B::optimize_thin(cgcx, module);
let module = B::codegen(cgcx, module, module_config);
WorkItemResult::Finished(module)
}
/// Messages sent to the coordinator.
@@ -1737,7 +1736,7 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
"codegen_copy_artifacts_from_incr_cache",
&*m.name,
);
Ok(execute_copy_from_cache_work_item(&cgcx, m, module_config))
execute_copy_from_cache_work_item(&cgcx, m, module_config)
}
WorkItem::FatLto {
exported_symbols_for_lto,
@@ -1766,12 +1765,11 @@ fn spawn_work<'a, B: ExtraBackendMethods>(
}));
let msg = match result {
Ok(Ok(result)) => Message::WorkItem::<B> { result: Ok(result) },
Ok(result) => Message::WorkItem::<B> { result: Ok(result) },
// We ignore any `FatalError` coming out of `execute_work_item`, as a
// diagnostic was already sent off to the main thread - just surface
// that there was an error in this worker.
Ok(Err(FatalError)) => Message::WorkItem::<B> { result: Err(Some(WorkerFatalError)) },
Err(err) if err.is::<FatalErrorMarker>() => {
Message::WorkItem::<B> { result: Err(Some(WorkerFatalError)) }
}