1use std::borrow::Cow;
4use std::ffi::OsString;
5use std::io::Error;
6use std::path::{Path, PathBuf};
7use std::process::ExitStatus;
8
9use rustc_errors::codes::*;
10use rustc_errors::{
11 Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level,
12};
13use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
14use rustc_middle::ty::layout::LayoutError;
15use rustc_middle::ty::{FloatTy, Ty};
16use rustc_span::{Span, Symbol};
17
18use crate::assert_module_sources::CguReuse;
19use crate::back::command::Command;
20use crate::fluent_generated as fluent;
21
22#[derive(Diagnostic)]
23#[diag(codegen_ssa_incorrect_cgu_reuse_type)]
24pub(crate) struct IncorrectCguReuseType<'a> {
25 #[primary_span]
26 pub span: Span,
27 pub cgu_user_name: &'a str,
28 pub actual_reuse: CguReuse,
29 pub expected_reuse: CguReuse,
30 pub at_least: u8,
31}
32
33#[derive(Diagnostic)]
34#[diag(codegen_ssa_cgu_not_recorded)]
35pub(crate) struct CguNotRecorded<'a> {
36 pub cgu_user_name: &'a str,
37 pub cgu_name: &'a str,
38}
39
40#[derive(Diagnostic)]
41#[diag(codegen_ssa_autodiff_without_lto)]
42pub struct AutodiffWithoutLto;
43
44#[derive(Diagnostic)]
45#[diag(codegen_ssa_unknown_reuse_kind)]
46pub(crate) struct UnknownReuseKind {
47 #[primary_span]
48 pub span: Span,
49 pub kind: Symbol,
50}
51
52#[derive(Diagnostic)]
53#[diag(codegen_ssa_missing_query_depgraph)]
54pub(crate) struct MissingQueryDepGraph {
55 #[primary_span]
56 pub span: Span,
57}
58
59#[derive(Diagnostic)]
60#[diag(codegen_ssa_malformed_cgu_name)]
61pub(crate) struct MalformedCguName {
62 #[primary_span]
63 pub span: Span,
64 pub user_path: String,
65 pub crate_name: String,
66}
67
68#[derive(Diagnostic)]
69#[diag(codegen_ssa_no_module_named)]
70pub(crate) struct NoModuleNamed<'a> {
71 #[primary_span]
72 pub span: Span,
73 pub user_path: &'a str,
74 pub cgu_name: Symbol,
75 pub cgu_names: String,
76}
77
78#[derive(Diagnostic)]
79#[diag(codegen_ssa_field_associated_value_expected)]
80pub(crate) struct FieldAssociatedValueExpected {
81 #[primary_span]
82 pub span: Span,
83 pub name: Symbol,
84}
85
86#[derive(Diagnostic)]
87#[diag(codegen_ssa_no_field)]
88pub(crate) struct NoField {
89 #[primary_span]
90 pub span: Span,
91 pub name: Symbol,
92}
93
94#[derive(Diagnostic)]
95#[diag(codegen_ssa_lib_def_write_failure)]
96pub(crate) struct LibDefWriteFailure {
97 pub error: Error,
98}
99
100#[derive(Diagnostic)]
101#[diag(codegen_ssa_version_script_write_failure)]
102pub(crate) struct VersionScriptWriteFailure {
103 pub error: Error,
104}
105
106#[derive(Diagnostic)]
107#[diag(codegen_ssa_symbol_file_write_failure)]
108pub(crate) struct SymbolFileWriteFailure {
109 pub error: Error,
110}
111
112#[derive(Diagnostic)]
113#[diag(codegen_ssa_ld64_unimplemented_modifier)]
114pub(crate) struct Ld64UnimplementedModifier;
115
116#[derive(Diagnostic)]
117#[diag(codegen_ssa_linker_unsupported_modifier)]
118pub(crate) struct LinkerUnsupportedModifier;
119
120#[derive(Diagnostic)]
121#[diag(codegen_ssa_L4Bender_exporting_symbols_unimplemented)]
122pub(crate) struct L4BenderExportingSymbolsUnimplemented;
123
124#[derive(Diagnostic)]
125#[diag(codegen_ssa_no_natvis_directory)]
126pub(crate) struct NoNatvisDirectory {
127 pub error: Error,
128}
129
130#[derive(Diagnostic)]
131#[diag(codegen_ssa_no_saved_object_file)]
132pub(crate) struct NoSavedObjectFile<'a> {
133 pub cgu_name: &'a str,
134}
135
136#[derive(Diagnostic)]
137#[diag(codegen_ssa_requires_rust_abi, code = E0737)]
138pub(crate) struct RequiresRustAbi {
139 #[primary_span]
140 pub span: Span,
141}
142
143#[derive(Diagnostic)]
144#[diag(codegen_ssa_null_on_export, code = E0648)]
145pub(crate) struct NullOnExport {
146 #[primary_span]
147 pub span: Span,
148}
149
150#[derive(Diagnostic)]
151#[diag(codegen_ssa_unsupported_instruction_set, code = E0779)]
152pub(crate) struct UnsupportedInstructionSet {
153 #[primary_span]
154 pub span: Span,
155}
156
157#[derive(Diagnostic)]
158#[diag(codegen_ssa_invalid_instruction_set, code = E0779)]
159pub(crate) struct InvalidInstructionSet {
160 #[primary_span]
161 pub span: Span,
162}
163
164#[derive(Diagnostic)]
165#[diag(codegen_ssa_bare_instruction_set, code = E0778)]
166pub(crate) struct BareInstructionSet {
167 #[primary_span]
168 pub span: Span,
169}
170
171#[derive(Diagnostic)]
172#[diag(codegen_ssa_multiple_instruction_set, code = E0779)]
173pub(crate) struct MultipleInstructionSet {
174 #[primary_span]
175 pub span: Span,
176}
177
178#[derive(Diagnostic)]
179#[diag(codegen_ssa_expected_name_value_pair)]
180pub(crate) struct ExpectedNameValuePair {
181 #[primary_span]
182 pub span: Span,
183}
184
185#[derive(Diagnostic)]
186#[diag(codegen_ssa_unexpected_parameter_name)]
187pub(crate) struct UnexpectedParameterName {
188 #[primary_span]
189 #[label]
190 pub span: Span,
191 pub prefix_nops: Symbol,
192 pub entry_nops: Symbol,
193}
194
195#[derive(Diagnostic)]
196#[diag(codegen_ssa_invalid_literal_value)]
197pub(crate) struct InvalidLiteralValue {
198 #[primary_span]
199 #[label]
200 pub span: Span,
201}
202
203#[derive(Diagnostic)]
204#[diag(codegen_ssa_out_of_range_integer)]
205pub(crate) struct OutOfRangeInteger {
206 #[primary_span]
207 #[label]
208 pub span: Span,
209}
210
211#[derive(Diagnostic)]
212#[diag(codegen_ssa_expected_one_argument, code = E0534)]
213pub(crate) struct ExpectedOneArgument {
214 #[primary_span]
215 pub span: Span,
216}
217
218#[derive(Diagnostic)]
219#[diag(codegen_ssa_expected_one_argument, code = E0722)]
220pub(crate) struct ExpectedOneArgumentOptimize {
221 #[primary_span]
222 pub span: Span,
223}
224
225#[derive(Diagnostic)]
226#[diag(codegen_ssa_invalid_argument, code = E0535)]
227#[help]
228pub(crate) struct InvalidArgument {
229 #[primary_span]
230 pub span: Span,
231}
232
233#[derive(Diagnostic)]
234#[diag(codegen_ssa_invalid_argument, code = E0722)]
235pub(crate) struct InvalidArgumentOptimize {
236 #[primary_span]
237 pub span: Span,
238}
239
240#[derive(Diagnostic)]
241#[diag(codegen_ssa_copy_path_buf)]
242pub(crate) struct CopyPathBuf {
243 pub source_file: PathBuf,
244 pub output_path: PathBuf,
245 pub error: Error,
246}
247
248#[derive(Diagnostic)]
250#[diag(codegen_ssa_copy_path)]
251pub struct CopyPath<'a> {
252 from: DebugArgPath<'a>,
253 to: DebugArgPath<'a>,
254 error: Error,
255}
256
257impl<'a> CopyPath<'a> {
258 pub fn new(from: &'a Path, to: &'a Path, error: Error) -> CopyPath<'a> {
259 CopyPath { from: DebugArgPath(from), to: DebugArgPath(to), error }
260 }
261}
262
263struct DebugArgPath<'a>(pub &'a Path);
264
265impl IntoDiagArg for DebugArgPath<'_> {
266 fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
267 DiagArgValue::Str(Cow::Owned(format!("{:?}", self.0)))
268 }
269}
270
271#[derive(Diagnostic)]
272#[diag(codegen_ssa_binary_output_to_tty)]
273pub struct BinaryOutputToTty {
274 pub shorthand: &'static str,
275}
276
277#[derive(Diagnostic)]
278#[diag(codegen_ssa_ignoring_emit_path)]
279pub struct IgnoringEmitPath {
280 pub extension: &'static str,
281}
282
283#[derive(Diagnostic)]
284#[diag(codegen_ssa_ignoring_output)]
285pub struct IgnoringOutput {
286 pub extension: &'static str,
287}
288
289#[derive(Diagnostic)]
290#[diag(codegen_ssa_create_temp_dir)]
291pub(crate) struct CreateTempDir {
292 pub error: Error,
293}
294
295#[derive(Diagnostic)]
296#[diag(codegen_ssa_add_native_library)]
297pub(crate) struct AddNativeLibrary {
298 pub library_path: PathBuf,
299 pub error: Error,
300}
301
302#[derive(Diagnostic)]
303#[diag(codegen_ssa_multiple_external_func_decl)]
304pub(crate) struct MultipleExternalFuncDecl<'a> {
305 #[primary_span]
306 pub span: Span,
307 pub function: Symbol,
308 pub library_name: &'a str,
309}
310
311#[derive(Diagnostic)]
312pub enum LinkRlibError {
313 #[diag(codegen_ssa_rlib_missing_format)]
314 MissingFormat,
315
316 #[diag(codegen_ssa_rlib_only_rmeta_found)]
317 OnlyRmetaFound { crate_name: Symbol },
318
319 #[diag(codegen_ssa_rlib_not_found)]
320 NotFound { crate_name: Symbol },
321
322 #[diag(codegen_ssa_rlib_incompatible_dependency_formats)]
323 IncompatibleDependencyFormats { ty1: String, ty2: String, list1: String, list2: String },
324}
325
326pub(crate) struct ThorinErrorWrapper(pub thorin::Error);
327
328impl<G: EmissionGuarantee> Diagnostic<'_, G> for ThorinErrorWrapper {
329 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
330 let build = |msg| Diag::new(dcx, level, msg);
331 match self.0 {
332 thorin::Error::ReadInput(_) => build(fluent::codegen_ssa_thorin_read_input_failure),
333 thorin::Error::ParseFileKind(_) => {
334 build(fluent::codegen_ssa_thorin_parse_input_file_kind)
335 }
336 thorin::Error::ParseObjectFile(_) => {
337 build(fluent::codegen_ssa_thorin_parse_input_object_file)
338 }
339 thorin::Error::ParseArchiveFile(_) => {
340 build(fluent::codegen_ssa_thorin_parse_input_archive_file)
341 }
342 thorin::Error::ParseArchiveMember(_) => {
343 build(fluent::codegen_ssa_thorin_parse_archive_member)
344 }
345 thorin::Error::InvalidInputKind => build(fluent::codegen_ssa_thorin_invalid_input_kind),
346 thorin::Error::DecompressData(_) => build(fluent::codegen_ssa_thorin_decompress_data),
347 thorin::Error::NamelessSection(_, offset) => {
348 build(fluent::codegen_ssa_thorin_section_without_name)
349 .with_arg("offset", format!("0x{offset:08x}"))
350 }
351 thorin::Error::RelocationWithInvalidSymbol(section, offset) => {
352 build(fluent::codegen_ssa_thorin_relocation_with_invalid_symbol)
353 .with_arg("section", section)
354 .with_arg("offset", format!("0x{offset:08x}"))
355 }
356 thorin::Error::MultipleRelocations(section, offset) => {
357 build(fluent::codegen_ssa_thorin_multiple_relocations)
358 .with_arg("section", section)
359 .with_arg("offset", format!("0x{offset:08x}"))
360 }
361 thorin::Error::UnsupportedRelocation(section, offset) => {
362 build(fluent::codegen_ssa_thorin_unsupported_relocation)
363 .with_arg("section", section)
364 .with_arg("offset", format!("0x{offset:08x}"))
365 }
366 thorin::Error::MissingDwoName(id) => build(fluent::codegen_ssa_thorin_missing_dwo_name)
367 .with_arg("id", format!("0x{id:08x}")),
368 thorin::Error::NoCompilationUnits => {
369 build(fluent::codegen_ssa_thorin_no_compilation_units)
370 }
371 thorin::Error::NoDie => build(fluent::codegen_ssa_thorin_no_die),
372 thorin::Error::TopLevelDieNotUnit => {
373 build(fluent::codegen_ssa_thorin_top_level_die_not_unit)
374 }
375 thorin::Error::MissingRequiredSection(section) => {
376 build(fluent::codegen_ssa_thorin_missing_required_section)
377 .with_arg("section", section)
378 }
379 thorin::Error::ParseUnitAbbreviations(_) => {
380 build(fluent::codegen_ssa_thorin_parse_unit_abbreviations)
381 }
382 thorin::Error::ParseUnitAttribute(_) => {
383 build(fluent::codegen_ssa_thorin_parse_unit_attribute)
384 }
385 thorin::Error::ParseUnitHeader(_) => {
386 build(fluent::codegen_ssa_thorin_parse_unit_header)
387 }
388 thorin::Error::ParseUnit(_) => build(fluent::codegen_ssa_thorin_parse_unit),
389 thorin::Error::IncompatibleIndexVersion(section, format, actual) => {
390 build(fluent::codegen_ssa_thorin_incompatible_index_version)
391 .with_arg("section", section)
392 .with_arg("actual", actual)
393 .with_arg("format", format)
394 }
395 thorin::Error::OffsetAtIndex(_, index) => {
396 build(fluent::codegen_ssa_thorin_offset_at_index).with_arg("index", index)
397 }
398 thorin::Error::StrAtOffset(_, offset) => {
399 build(fluent::codegen_ssa_thorin_str_at_offset)
400 .with_arg("offset", format!("0x{offset:08x}"))
401 }
402 thorin::Error::ParseIndex(_, section) => {
403 build(fluent::codegen_ssa_thorin_parse_index).with_arg("section", section)
404 }
405 thorin::Error::UnitNotInIndex(unit) => {
406 build(fluent::codegen_ssa_thorin_unit_not_in_index)
407 .with_arg("unit", format!("0x{unit:08x}"))
408 }
409 thorin::Error::RowNotInIndex(_, row) => {
410 build(fluent::codegen_ssa_thorin_row_not_in_index).with_arg("row", row)
411 }
412 thorin::Error::SectionNotInRow => build(fluent::codegen_ssa_thorin_section_not_in_row),
413 thorin::Error::EmptyUnit(unit) => build(fluent::codegen_ssa_thorin_empty_unit)
414 .with_arg("unit", format!("0x{unit:08x}")),
415 thorin::Error::MultipleDebugInfoSection => {
416 build(fluent::codegen_ssa_thorin_multiple_debug_info_section)
417 }
418 thorin::Error::MultipleDebugTypesSection => {
419 build(fluent::codegen_ssa_thorin_multiple_debug_types_section)
420 }
421 thorin::Error::NotSplitUnit => build(fluent::codegen_ssa_thorin_not_split_unit),
422 thorin::Error::DuplicateUnit(unit) => build(fluent::codegen_ssa_thorin_duplicate_unit)
423 .with_arg("unit", format!("0x{unit:08x}")),
424 thorin::Error::MissingReferencedUnit(unit) => {
425 build(fluent::codegen_ssa_thorin_missing_referenced_unit)
426 .with_arg("unit", format!("0x{unit:08x}"))
427 }
428 thorin::Error::NoOutputObjectCreated => {
429 build(fluent::codegen_ssa_thorin_not_output_object_created)
430 }
431 thorin::Error::MixedInputEncodings => {
432 build(fluent::codegen_ssa_thorin_mixed_input_encodings)
433 }
434 thorin::Error::Io(e) => {
435 build(fluent::codegen_ssa_thorin_io).with_arg("error", format!("{e}"))
436 }
437 thorin::Error::ObjectRead(e) => {
438 build(fluent::codegen_ssa_thorin_object_read).with_arg("error", format!("{e}"))
439 }
440 thorin::Error::ObjectWrite(e) => {
441 build(fluent::codegen_ssa_thorin_object_write).with_arg("error", format!("{e}"))
442 }
443 thorin::Error::GimliRead(e) => {
444 build(fluent::codegen_ssa_thorin_gimli_read).with_arg("error", format!("{e}"))
445 }
446 thorin::Error::GimliWrite(e) => {
447 build(fluent::codegen_ssa_thorin_gimli_write).with_arg("error", format!("{e}"))
448 }
449 _ => unimplemented!("Untranslated thorin error"),
450 }
451 }
452}
453
454pub(crate) struct LinkingFailed<'a> {
455 pub linker_path: &'a Path,
456 pub exit_status: ExitStatus,
457 pub command: Command,
458 pub escaped_output: String,
459 pub verbose: bool,
460 pub sysroot_dir: PathBuf,
461}
462
463impl<G: EmissionGuarantee> Diagnostic<'_, G> for LinkingFailed<'_> {
464 fn into_diag(mut self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
465 let mut diag = Diag::new(dcx, level, fluent::codegen_ssa_linking_failed);
466 diag.arg("linker_path", format!("{}", self.linker_path.display()));
467 diag.arg("exit_status", format!("{}", self.exit_status));
468
469 let contains_undefined_ref = self.escaped_output.contains("undefined reference to");
470
471 if self.verbose {
472 diag.note(format!("{:?}", self.command));
473 } else {
474 self.command.env_clear();
475
476 enum ArgGroup {
477 Regular(OsString),
478 Objects(usize),
479 Rlibs(PathBuf, Vec<OsString>),
480 }
481
482 let orig_args = self.command.take_args();
485 let mut args: Vec<ArgGroup> = vec![];
486 for arg in orig_args {
487 if arg.as_encoded_bytes().ends_with(b".rcgu.o") {
488 if let Some(ArgGroup::Objects(n)) = args.last_mut() {
489 *n += 1;
490 } else {
491 args.push(ArgGroup::Objects(1));
492 }
493 } else if arg.as_encoded_bytes().ends_with(b".rlib") {
494 let rlib_path = Path::new(&arg);
495 let dir = rlib_path.parent().unwrap();
496 let filename = rlib_path.file_name().unwrap().to_owned();
497 if let Some(ArgGroup::Rlibs(parent, rlibs)) = args.last_mut() {
498 if parent == dir {
499 rlibs.push(filename);
500 } else {
501 args.push(ArgGroup::Rlibs(dir.to_owned(), vec![filename]));
502 }
503 } else {
504 args.push(ArgGroup::Rlibs(dir.to_owned(), vec![filename]));
505 }
506 } else {
507 args.push(ArgGroup::Regular(arg));
508 }
509 }
510 let crate_hash = regex::bytes::Regex::new(r"-[0-9a-f]+\.rlib$").unwrap();
511 self.command.args(args.into_iter().map(|arg_group| {
512 match arg_group {
513 ArgGroup::Regular(arg) => unsafe {
515 use bstr::ByteSlice;
516 OsString::from_encoded_bytes_unchecked(
517 arg.as_encoded_bytes().replace(
518 self.sysroot_dir.as_os_str().as_encoded_bytes(),
519 b"<sysroot>",
520 ),
521 )
522 },
523 ArgGroup::Objects(n) => OsString::from(format!("<{n} object files omitted>")),
524 ArgGroup::Rlibs(mut dir, rlibs) => {
525 let is_sysroot_dir = match dir.strip_prefix(&self.sysroot_dir) {
526 Ok(short) => {
527 dir = Path::new("<sysroot>").join(short);
528 true
529 }
530 Err(_) => false,
531 };
532 let mut arg = dir.into_os_string();
533 arg.push("/{");
534 let mut first = true;
535 for mut rlib in rlibs {
536 if !first {
537 arg.push(",");
538 }
539 first = false;
540 if is_sysroot_dir {
541 rlib = unsafe {
543 OsString::from_encoded_bytes_unchecked(
544 crate_hash
545 .replace(rlib.as_encoded_bytes(), b"-*")
546 .into_owned(),
547 )
548 };
549 }
550 arg.push(rlib);
551 }
552 arg.push("}.rlib");
553 arg
554 }
555 }
556 }));
557
558 diag.note(format!("{:?}", self.command).trim_start_matches("env -i").to_owned());
559 diag.note("some arguments are omitted. use `--verbose` to show all linker arguments");
560 }
561
562 diag.note(self.escaped_output);
563
564 if contains_undefined_ref {
567 diag.note(fluent::codegen_ssa_extern_funcs_not_found)
568 .note(fluent::codegen_ssa_specify_libraries_to_link);
569
570 if rustc_session::utils::was_invoked_from_cargo() {
571 diag.note(fluent::codegen_ssa_use_cargo_directive);
572 }
573 }
574 diag
575 }
576}
577
578#[derive(Diagnostic)]
579#[diag(codegen_ssa_link_exe_unexpected_error)]
580pub(crate) struct LinkExeUnexpectedError;
581
582#[derive(Diagnostic)]
583#[diag(codegen_ssa_repair_vs_build_tools)]
584pub(crate) struct RepairVSBuildTools;
585
586#[derive(Diagnostic)]
587#[diag(codegen_ssa_missing_cpp_build_tool_component)]
588pub(crate) struct MissingCppBuildToolComponent;
589
590#[derive(Diagnostic)]
591#[diag(codegen_ssa_select_cpp_build_tool_workload)]
592pub(crate) struct SelectCppBuildToolWorkload;
593
594#[derive(Diagnostic)]
595#[diag(codegen_ssa_visual_studio_not_installed)]
596pub(crate) struct VisualStudioNotInstalled;
597
598#[derive(Diagnostic)]
599#[diag(codegen_ssa_linker_not_found)]
600#[note]
601pub(crate) struct LinkerNotFound {
602 pub linker_path: PathBuf,
603 pub error: Error,
604}
605
606#[derive(Diagnostic)]
607#[diag(codegen_ssa_unable_to_exe_linker)]
608#[note]
609#[note(codegen_ssa_command_note)]
610pub(crate) struct UnableToExeLinker {
611 pub linker_path: PathBuf,
612 pub error: Error,
613 pub command_formatted: String,
614}
615
616#[derive(Diagnostic)]
617#[diag(codegen_ssa_msvc_missing_linker)]
618pub(crate) struct MsvcMissingLinker;
619
620#[derive(Diagnostic)]
621#[diag(codegen_ssa_self_contained_linker_missing)]
622pub(crate) struct SelfContainedLinkerMissing;
623
624#[derive(Diagnostic)]
625#[diag(codegen_ssa_check_installed_visual_studio)]
626pub(crate) struct CheckInstalledVisualStudio;
627
628#[derive(Diagnostic)]
629#[diag(codegen_ssa_insufficient_vs_code_product)]
630pub(crate) struct InsufficientVSCodeProduct;
631
632#[derive(Diagnostic)]
633#[diag(codegen_ssa_cpu_required)]
634pub(crate) struct CpuRequired;
635
636#[derive(Diagnostic)]
637#[diag(codegen_ssa_processing_dymutil_failed)]
638#[note]
639pub(crate) struct ProcessingDymutilFailed {
640 pub status: ExitStatus,
641 pub output: String,
642}
643
644#[derive(Diagnostic)]
645#[diag(codegen_ssa_unable_to_run_dsymutil)]
646pub(crate) struct UnableToRunDsymutil {
647 pub error: Error,
648}
649
650#[derive(Diagnostic)]
651#[diag(codegen_ssa_stripping_debug_info_failed)]
652#[note]
653pub(crate) struct StrippingDebugInfoFailed<'a> {
654 pub util: &'a str,
655 pub status: ExitStatus,
656 pub output: String,
657}
658
659#[derive(Diagnostic)]
660#[diag(codegen_ssa_unable_to_run)]
661pub(crate) struct UnableToRun<'a> {
662 pub util: &'a str,
663 pub error: Error,
664}
665
666#[derive(Diagnostic)]
667#[diag(codegen_ssa_linker_file_stem)]
668pub(crate) struct LinkerFileStem;
669
670#[derive(Diagnostic)]
671#[diag(codegen_ssa_static_library_native_artifacts)]
672pub(crate) struct StaticLibraryNativeArtifacts;
673
674#[derive(Diagnostic)]
675#[diag(codegen_ssa_static_library_native_artifacts_to_file)]
676pub(crate) struct StaticLibraryNativeArtifactsToFile<'a> {
677 pub path: &'a Path,
678}
679
680#[derive(Diagnostic)]
681#[diag(codegen_ssa_link_script_unavailable)]
682pub(crate) struct LinkScriptUnavailable;
683
684#[derive(Diagnostic)]
685#[diag(codegen_ssa_link_script_write_failure)]
686pub(crate) struct LinkScriptWriteFailure {
687 pub path: PathBuf,
688 pub error: Error,
689}
690
691#[derive(Diagnostic)]
692#[diag(codegen_ssa_failed_to_write)]
693pub(crate) struct FailedToWrite {
694 pub path: PathBuf,
695 pub error: Error,
696}
697
698#[derive(Diagnostic)]
699#[diag(codegen_ssa_unable_to_write_debugger_visualizer)]
700pub(crate) struct UnableToWriteDebuggerVisualizer {
701 pub path: PathBuf,
702 pub error: Error,
703}
704
705#[derive(Diagnostic)]
706#[diag(codegen_ssa_rlib_archive_build_failure)]
707pub(crate) struct RlibArchiveBuildFailure {
708 pub path: PathBuf,
709 pub error: Error,
710}
711
712#[derive(Diagnostic)]
713pub enum ExtractBundledLibsError<'a> {
715 #[diag(codegen_ssa_extract_bundled_libs_open_file)]
716 OpenFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
717
718 #[diag(codegen_ssa_extract_bundled_libs_mmap_file)]
719 MmapFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
720
721 #[diag(codegen_ssa_extract_bundled_libs_parse_archive)]
722 ParseArchive { rlib: &'a Path, error: Box<dyn std::error::Error> },
723
724 #[diag(codegen_ssa_extract_bundled_libs_read_entry)]
725 ReadEntry { rlib: &'a Path, error: Box<dyn std::error::Error> },
726
727 #[diag(codegen_ssa_extract_bundled_libs_archive_member)]
728 ArchiveMember { rlib: &'a Path, error: Box<dyn std::error::Error> },
729
730 #[diag(codegen_ssa_extract_bundled_libs_convert_name)]
731 ConvertName { rlib: &'a Path, error: Box<dyn std::error::Error> },
732
733 #[diag(codegen_ssa_extract_bundled_libs_write_file)]
734 WriteFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
735
736 #[diag(codegen_ssa_extract_bundled_libs_write_file)]
737 ExtractSection { rlib: &'a Path, error: Box<dyn std::error::Error> },
738}
739
740#[derive(Diagnostic)]
741#[diag(codegen_ssa_read_file)]
742pub(crate) struct ReadFileError {
743 pub message: std::io::Error,
744}
745
746#[derive(Diagnostic)]
747#[diag(codegen_ssa_unsupported_link_self_contained)]
748pub(crate) struct UnsupportedLinkSelfContained;
749
750#[derive(Diagnostic)]
751#[diag(codegen_ssa_archive_build_failure)]
752pub struct ArchiveBuildFailure {
754 pub path: PathBuf,
755 pub error: std::io::Error,
756}
757
758#[derive(Diagnostic)]
759#[diag(codegen_ssa_unknown_archive_kind)]
760pub struct UnknownArchiveKind<'a> {
762 pub kind: &'a str,
763}
764
765#[derive(Diagnostic)]
766#[diag(codegen_ssa_expected_used_symbol)]
767pub(crate) struct ExpectedUsedSymbol {
768 #[primary_span]
769 pub span: Span,
770}
771
772#[derive(Diagnostic)]
773#[diag(codegen_ssa_multiple_main_functions)]
774#[help]
775pub(crate) struct MultipleMainFunctions {
776 #[primary_span]
777 pub span: Span,
778}
779
780#[derive(Diagnostic)]
781#[diag(codegen_ssa_metadata_object_file_write)]
782pub(crate) struct MetadataObjectFileWrite {
783 pub error: Error,
784}
785
786#[derive(Diagnostic)]
787#[diag(codegen_ssa_invalid_windows_subsystem)]
788pub(crate) struct InvalidWindowsSubsystem {
789 pub subsystem: Symbol,
790}
791
792#[derive(Diagnostic)]
793#[diag(codegen_ssa_shuffle_indices_evaluation)]
794pub(crate) struct ShuffleIndicesEvaluation {
795 #[primary_span]
796 pub span: Span,
797}
798
799#[derive(Diagnostic)]
800pub enum InvalidMonomorphization<'tcx> {
801 #[diag(codegen_ssa_invalid_monomorphization_basic_integer_type, code = E0511)]
802 BasicIntegerType {
803 #[primary_span]
804 span: Span,
805 name: Symbol,
806 ty: Ty<'tcx>,
807 },
808
809 #[diag(codegen_ssa_invalid_monomorphization_basic_float_type, code = E0511)]
810 BasicFloatType {
811 #[primary_span]
812 span: Span,
813 name: Symbol,
814 ty: Ty<'tcx>,
815 },
816
817 #[diag(codegen_ssa_invalid_monomorphization_float_to_int_unchecked, code = E0511)]
818 FloatToIntUnchecked {
819 #[primary_span]
820 span: Span,
821 ty: Ty<'tcx>,
822 },
823
824 #[diag(codegen_ssa_invalid_monomorphization_floating_point_vector, code = E0511)]
825 FloatingPointVector {
826 #[primary_span]
827 span: Span,
828 name: Symbol,
829 f_ty: FloatTy,
830 in_ty: Ty<'tcx>,
831 },
832
833 #[diag(codegen_ssa_invalid_monomorphization_floating_point_type, code = E0511)]
834 FloatingPointType {
835 #[primary_span]
836 span: Span,
837 name: Symbol,
838 in_ty: Ty<'tcx>,
839 },
840
841 #[diag(codegen_ssa_invalid_monomorphization_unrecognized_intrinsic, code = E0511)]
842 UnrecognizedIntrinsic {
843 #[primary_span]
844 span: Span,
845 name: Symbol,
846 },
847
848 #[diag(codegen_ssa_invalid_monomorphization_simd_argument, code = E0511)]
849 SimdArgument {
850 #[primary_span]
851 span: Span,
852 name: Symbol,
853 ty: Ty<'tcx>,
854 },
855
856 #[diag(codegen_ssa_invalid_monomorphization_simd_input, code = E0511)]
857 SimdInput {
858 #[primary_span]
859 span: Span,
860 name: Symbol,
861 ty: Ty<'tcx>,
862 },
863
864 #[diag(codegen_ssa_invalid_monomorphization_simd_first, code = E0511)]
865 SimdFirst {
866 #[primary_span]
867 span: Span,
868 name: Symbol,
869 ty: Ty<'tcx>,
870 },
871
872 #[diag(codegen_ssa_invalid_monomorphization_simd_second, code = E0511)]
873 SimdSecond {
874 #[primary_span]
875 span: Span,
876 name: Symbol,
877 ty: Ty<'tcx>,
878 },
879
880 #[diag(codegen_ssa_invalid_monomorphization_simd_third, code = E0511)]
881 SimdThird {
882 #[primary_span]
883 span: Span,
884 name: Symbol,
885 ty: Ty<'tcx>,
886 },
887
888 #[diag(codegen_ssa_invalid_monomorphization_simd_return, code = E0511)]
889 SimdReturn {
890 #[primary_span]
891 span: Span,
892 name: Symbol,
893 ty: Ty<'tcx>,
894 },
895
896 #[diag(codegen_ssa_invalid_monomorphization_invalid_bitmask, code = E0511)]
897 InvalidBitmask {
898 #[primary_span]
899 span: Span,
900 name: Symbol,
901 mask_ty: Ty<'tcx>,
902 expected_int_bits: u64,
903 expected_bytes: u64,
904 },
905
906 #[diag(codegen_ssa_invalid_monomorphization_return_length_input_type, code = E0511)]
907 ReturnLengthInputType {
908 #[primary_span]
909 span: Span,
910 name: Symbol,
911 in_len: u64,
912 in_ty: Ty<'tcx>,
913 ret_ty: Ty<'tcx>,
914 out_len: u64,
915 },
916
917 #[diag(codegen_ssa_invalid_monomorphization_second_argument_length, code = E0511)]
918 SecondArgumentLength {
919 #[primary_span]
920 span: Span,
921 name: Symbol,
922 in_len: u64,
923 in_ty: Ty<'tcx>,
924 arg_ty: Ty<'tcx>,
925 out_len: u64,
926 },
927
928 #[diag(codegen_ssa_invalid_monomorphization_third_argument_length, code = E0511)]
929 ThirdArgumentLength {
930 #[primary_span]
931 span: Span,
932 name: Symbol,
933 in_len: u64,
934 in_ty: Ty<'tcx>,
935 arg_ty: Ty<'tcx>,
936 out_len: u64,
937 },
938
939 #[diag(codegen_ssa_invalid_monomorphization_return_integer_type, code = E0511)]
940 ReturnIntegerType {
941 #[primary_span]
942 span: Span,
943 name: Symbol,
944 ret_ty: Ty<'tcx>,
945 out_ty: Ty<'tcx>,
946 },
947
948 #[diag(codegen_ssa_invalid_monomorphization_simd_shuffle, code = E0511)]
949 SimdShuffle {
950 #[primary_span]
951 span: Span,
952 name: Symbol,
953 ty: Ty<'tcx>,
954 },
955
956 #[diag(codegen_ssa_invalid_monomorphization_return_length, code = E0511)]
957 ReturnLength {
958 #[primary_span]
959 span: Span,
960 name: Symbol,
961 in_len: u64,
962 ret_ty: Ty<'tcx>,
963 out_len: u64,
964 },
965
966 #[diag(codegen_ssa_invalid_monomorphization_return_element, code = E0511)]
967 ReturnElement {
968 #[primary_span]
969 span: Span,
970 name: Symbol,
971 in_elem: Ty<'tcx>,
972 in_ty: Ty<'tcx>,
973 ret_ty: Ty<'tcx>,
974 out_ty: Ty<'tcx>,
975 },
976
977 #[diag(codegen_ssa_invalid_monomorphization_simd_index_out_of_bounds, code = E0511)]
978 SimdIndexOutOfBounds {
979 #[primary_span]
980 span: Span,
981 name: Symbol,
982 arg_idx: u64,
983 total_len: u128,
984 },
985
986 #[diag(codegen_ssa_invalid_monomorphization_inserted_type, code = E0511)]
987 InsertedType {
988 #[primary_span]
989 span: Span,
990 name: Symbol,
991 in_elem: Ty<'tcx>,
992 in_ty: Ty<'tcx>,
993 out_ty: Ty<'tcx>,
994 },
995
996 #[diag(codegen_ssa_invalid_monomorphization_return_type, code = E0511)]
997 ReturnType {
998 #[primary_span]
999 span: Span,
1000 name: Symbol,
1001 in_elem: Ty<'tcx>,
1002 in_ty: Ty<'tcx>,
1003 ret_ty: Ty<'tcx>,
1004 },
1005
1006 #[diag(codegen_ssa_invalid_monomorphization_expected_return_type, code = E0511)]
1007 ExpectedReturnType {
1008 #[primary_span]
1009 span: Span,
1010 name: Symbol,
1011 in_ty: Ty<'tcx>,
1012 ret_ty: Ty<'tcx>,
1013 },
1014
1015 #[diag(codegen_ssa_invalid_monomorphization_mismatched_lengths, code = E0511)]
1016 MismatchedLengths {
1017 #[primary_span]
1018 span: Span,
1019 name: Symbol,
1020 m_len: u64,
1021 v_len: u64,
1022 },
1023
1024 #[diag(codegen_ssa_invalid_monomorphization_mask_wrong_element_type, code = E0511)]
1025 MaskWrongElementType {
1026 #[primary_span]
1027 span: Span,
1028 name: Symbol,
1029 ty: Ty<'tcx>,
1030 },
1031
1032 #[diag(codegen_ssa_invalid_monomorphization_cannot_return, code = E0511)]
1033 CannotReturn {
1034 #[primary_span]
1035 span: Span,
1036 name: Symbol,
1037 ret_ty: Ty<'tcx>,
1038 expected_int_bits: u64,
1039 expected_bytes: u64,
1040 },
1041
1042 #[diag(codegen_ssa_invalid_monomorphization_expected_element_type, code = E0511)]
1043 ExpectedElementType {
1044 #[primary_span]
1045 span: Span,
1046 name: Symbol,
1047 expected_element: Ty<'tcx>,
1048 second_arg: Ty<'tcx>,
1049 in_elem: Ty<'tcx>,
1050 in_ty: Ty<'tcx>,
1051 mutability: ExpectedPointerMutability,
1052 },
1053
1054 #[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size, code = E0511)]
1055 UnsupportedSymbolOfSize {
1056 #[primary_span]
1057 span: Span,
1058 name: Symbol,
1059 symbol: Symbol,
1060 in_ty: Ty<'tcx>,
1061 in_elem: Ty<'tcx>,
1062 size: u64,
1063 ret_ty: Ty<'tcx>,
1064 },
1065
1066 #[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol, code = E0511)]
1067 UnsupportedSymbol {
1068 #[primary_span]
1069 span: Span,
1070 name: Symbol,
1071 symbol: Symbol,
1072 in_ty: Ty<'tcx>,
1073 in_elem: Ty<'tcx>,
1074 ret_ty: Ty<'tcx>,
1075 },
1076
1077 #[diag(codegen_ssa_invalid_monomorphization_cast_wide_pointer, code = E0511)]
1078 CastWidePointer {
1079 #[primary_span]
1080 span: Span,
1081 name: Symbol,
1082 ty: Ty<'tcx>,
1083 },
1084
1085 #[diag(codegen_ssa_invalid_monomorphization_expected_pointer, code = E0511)]
1086 ExpectedPointer {
1087 #[primary_span]
1088 span: Span,
1089 name: Symbol,
1090 ty: Ty<'tcx>,
1091 },
1092
1093 #[diag(codegen_ssa_invalid_monomorphization_expected_usize, code = E0511)]
1094 ExpectedUsize {
1095 #[primary_span]
1096 span: Span,
1097 name: Symbol,
1098 ty: Ty<'tcx>,
1099 },
1100
1101 #[diag(codegen_ssa_invalid_monomorphization_unsupported_cast, code = E0511)]
1102 UnsupportedCast {
1103 #[primary_span]
1104 span: Span,
1105 name: Symbol,
1106 in_ty: Ty<'tcx>,
1107 in_elem: Ty<'tcx>,
1108 ret_ty: Ty<'tcx>,
1109 out_elem: Ty<'tcx>,
1110 },
1111
1112 #[diag(codegen_ssa_invalid_monomorphization_unsupported_operation, code = E0511)]
1113 UnsupportedOperation {
1114 #[primary_span]
1115 span: Span,
1116 name: Symbol,
1117 in_ty: Ty<'tcx>,
1118 in_elem: Ty<'tcx>,
1119 },
1120
1121 #[diag(codegen_ssa_invalid_monomorphization_expected_vector_element_type, code = E0511)]
1122 ExpectedVectorElementType {
1123 #[primary_span]
1124 span: Span,
1125 name: Symbol,
1126 expected_element: Ty<'tcx>,
1127 vector_type: Ty<'tcx>,
1128 },
1129}
1130
1131pub enum ExpectedPointerMutability {
1132 Mut,
1133 Not,
1134}
1135
1136impl IntoDiagArg for ExpectedPointerMutability {
1137 fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
1138 match self {
1139 ExpectedPointerMutability::Mut => DiagArgValue::Str(Cow::Borrowed("*mut")),
1140 ExpectedPointerMutability::Not => DiagArgValue::Str(Cow::Borrowed("*_")),
1141 }
1142 }
1143}
1144
1145#[derive(Diagnostic)]
1146#[diag(codegen_ssa_invalid_no_sanitize)]
1147#[note]
1148pub(crate) struct InvalidNoSanitize {
1149 #[primary_span]
1150 pub span: Span,
1151}
1152
1153#[derive(Diagnostic)]
1154#[diag(codegen_ssa_invalid_link_ordinal_nargs)]
1155#[note]
1156pub(crate) struct InvalidLinkOrdinalNargs {
1157 #[primary_span]
1158 pub span: Span,
1159}
1160
1161#[derive(Diagnostic)]
1162#[diag(codegen_ssa_illegal_link_ordinal_format)]
1163#[note]
1164pub(crate) struct InvalidLinkOrdinalFormat {
1165 #[primary_span]
1166 pub span: Span,
1167}
1168
1169#[derive(Diagnostic)]
1170#[diag(codegen_ssa_target_feature_safe_trait)]
1171pub(crate) struct TargetFeatureSafeTrait {
1172 #[primary_span]
1173 #[label]
1174 pub span: Span,
1175 #[label(codegen_ssa_label_def)]
1176 pub def: Span,
1177}
1178
1179#[derive(Diagnostic)]
1180#[diag(codegen_ssa_forbidden_target_feature_attr)]
1181pub struct ForbiddenTargetFeatureAttr<'a> {
1182 #[primary_span]
1183 pub span: Span,
1184 pub feature: &'a str,
1185 pub reason: &'a str,
1186}
1187
1188#[derive(Diagnostic)]
1189#[diag(codegen_ssa_failed_to_get_layout)]
1190pub struct FailedToGetLayout<'tcx> {
1191 #[primary_span]
1192 pub span: Span,
1193 pub ty: Ty<'tcx>,
1194 pub err: LayoutError<'tcx>,
1195}
1196
1197#[derive(Diagnostic)]
1198#[diag(codegen_ssa_dlltool_fail_import_library)]
1199pub(crate) struct DlltoolFailImportLibrary<'a> {
1200 pub dlltool_path: Cow<'a, str>,
1201 pub dlltool_args: String,
1202 pub stdout: Cow<'a, str>,
1203 pub stderr: Cow<'a, str>,
1204}
1205
1206#[derive(Diagnostic)]
1207#[diag(codegen_ssa_error_writing_def_file)]
1208pub(crate) struct ErrorWritingDEFFile {
1209 pub error: std::io::Error,
1210}
1211
1212#[derive(Diagnostic)]
1213#[diag(codegen_ssa_error_calling_dlltool)]
1214pub(crate) struct ErrorCallingDllTool<'a> {
1215 pub dlltool_path: Cow<'a, str>,
1216 pub error: std::io::Error,
1217}
1218
1219#[derive(Diagnostic)]
1220#[diag(codegen_ssa_error_creating_remark_dir)]
1221pub(crate) struct ErrorCreatingRemarkDir {
1222 pub error: std::io::Error,
1223}
1224
1225#[derive(Diagnostic)]
1226#[diag(codegen_ssa_compiler_builtins_cannot_call)]
1227pub struct CompilerBuiltinsCannotCall {
1228 pub caller: String,
1229 pub callee: String,
1230 #[primary_span]
1231 pub span: Span,
1232}
1233
1234#[derive(Diagnostic)]
1235#[diag(codegen_ssa_error_creating_import_library)]
1236pub(crate) struct ErrorCreatingImportLibrary<'a> {
1237 pub lib_name: &'a str,
1238 pub error: String,
1239}
1240
1241pub struct TargetFeatureDisableOrEnable<'a> {
1242 pub features: &'a [&'a str],
1243 pub span: Option<Span>,
1244 pub missing_features: Option<MissingFeatures>,
1245}
1246
1247#[derive(Subdiagnostic)]
1248#[help(codegen_ssa_missing_features)]
1249pub struct MissingFeatures;
1250
1251impl<G: EmissionGuarantee> Diagnostic<'_, G> for TargetFeatureDisableOrEnable<'_> {
1252 fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
1253 let mut diag = Diag::new(dcx, level, fluent::codegen_ssa_target_feature_disable_or_enable);
1254 if let Some(span) = self.span {
1255 diag.span(span);
1256 };
1257 if let Some(missing_features) = self.missing_features {
1258 diag.subdiagnostic(missing_features);
1259 }
1260 diag.arg("features", self.features.join(", "));
1261 diag
1262 }
1263}
1264
1265#[derive(Diagnostic)]
1266#[diag(codegen_ssa_aix_strip_not_used)]
1267pub(crate) struct AixStripNotUsed;
1268
1269#[derive(LintDiagnostic)]
1270#[diag(codegen_ssa_mixed_export_name_and_no_mangle)]
1271pub(crate) struct MixedExportNameAndNoMangle {
1272 #[label]
1273 pub no_mangle: Span,
1274 pub no_mangle_attr: String,
1275 #[note]
1276 pub export_name: Span,
1277 #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
1278 pub removal_span: Span,
1279}
1280
1281#[derive(Diagnostic, Debug)]
1282pub(crate) enum XcrunError {
1283 #[diag(codegen_ssa_xcrun_failed_invoking)]
1284 FailedInvoking { sdk_name: &'static str, command_formatted: String, error: std::io::Error },
1285
1286 #[diag(codegen_ssa_xcrun_unsuccessful)]
1287 #[note]
1288 Unsuccessful {
1289 sdk_name: &'static str,
1290 command_formatted: String,
1291 stdout: String,
1292 stderr: String,
1293 },
1294}
1295
1296#[derive(Diagnostic, Debug)]
1297#[diag(codegen_ssa_xcrun_sdk_path_warning)]
1298#[note]
1299pub(crate) struct XcrunSdkPathWarning {
1300 pub sdk_name: &'static str,
1301 pub stderr: String,
1302}
1303
1304#[derive(LintDiagnostic)]
1305#[diag(codegen_ssa_aarch64_softfloat_neon)]
1306pub(crate) struct Aarch64SoftfloatNeon;