compiler/rustc_codegen_ssa/src/errors.rs

   1 //! Errors emitted by codegen_ssa
   2
   3 use crate::back::command::Command;
   4 use rustc_errors::{
   5     fluent, DiagnosticArgValue, DiagnosticBuilder, ErrorGuaranteed, Handler, IntoDiagnostic,
   6     IntoDiagnosticArg,
   7 };
   8 use rustc_macros::Diagnostic;
   9 use rustc_middle::ty::Ty;
  10 use rustc_span::{Span, Symbol};
  11 use rustc_type_ir::FloatTy;
  12 use std::borrow::Cow;
  13 use std::io::Error;
  14 use std::path::{Path, PathBuf};
  15 use std::process::ExitStatus;
  16
  17 #[derive(Diagnostic)]
  18 #[diag(codegen_ssa_lib_def_write_failure)]
  19 pub struct LibDefWriteFailure {
  20     pub error: Error,
  21 }
  22
  23 #[derive(Diagnostic)]
  24 #[diag(codegen_ssa_version_script_write_failure)]
  25 pub struct VersionScriptWriteFailure {
  26     pub error: Error,
  27 }
  28
  29 #[derive(Diagnostic)]
  30 #[diag(codegen_ssa_symbol_file_write_failure)]
  31 pub struct SymbolFileWriteFailure {
  32     pub error: Error,
  33 }
  34
  35 #[derive(Diagnostic)]
  36 #[diag(codegen_ssa_ld64_unimplemented_modifier)]
  37 pub struct Ld64UnimplementedModifier;
  38
  39 #[derive(Diagnostic)]
  40 #[diag(codegen_ssa_linker_unsupported_modifier)]
  41 pub struct LinkerUnsupportedModifier;
  42
  43 #[derive(Diagnostic)]
  44 #[diag(codegen_ssa_L4Bender_exporting_symbols_unimplemented)]
  45 pub struct L4BenderExportingSymbolsUnimplemented;
  46
  47 #[derive(Diagnostic)]
  48 #[diag(codegen_ssa_no_natvis_directory)]
  49 pub struct NoNatvisDirectory {
  50     pub error: Error,
  51 }
  52
  53 #[derive(Diagnostic)]
  54 #[diag(codegen_ssa_copy_path_buf)]
  55 pub struct CopyPathBuf {
  56     pub source_file: PathBuf,
  57     pub output_path: PathBuf,
  58     pub error: Error,
  59 }
  60
  61 // Reports Paths using `Debug` implementation rather than Path's `Display` implementation.
  62 #[derive(Diagnostic)]
  63 #[diag(codegen_ssa_copy_path)]
  64 pub struct CopyPath<'a> {
  65     from: DebugArgPath<'a>,
  66     to: DebugArgPath<'a>,
  67     error: Error,
  68 }
  69
  70 impl<'a> CopyPath<'a> {
  71     pub fn new(from: &'a Path, to: &'a Path, error: Error) -> CopyPath<'a> {
  72         CopyPath { from: DebugArgPath(from), to: DebugArgPath(to), error }
  73     }
  74 }
  75
  76 struct DebugArgPath<'a>(pub &'a Path);
  77
  78 impl IntoDiagnosticArg for DebugArgPath<'_> {
  79     fn into_diagnostic_arg(self) -> rustc_errors::DiagnosticArgValue<'static> {
  80         DiagnosticArgValue::Str(Cow::Owned(format!("{:?}", self.0)))
  81     }
  82 }
  83
  84 #[derive(Diagnostic)]
  85 #[diag(codegen_ssa_ignoring_emit_path)]
  86 pub struct IgnoringEmitPath {
  87     pub extension: String,
  88 }
  89
  90 #[derive(Diagnostic)]
  91 #[diag(codegen_ssa_ignoring_output)]
  92 pub struct IgnoringOutput {
  93     pub extension: String,
  94 }
  95
  96 #[derive(Diagnostic)]
  97 #[diag(codegen_ssa_create_temp_dir)]
  98 pub struct CreateTempDir {
  99     pub error: Error,
 100 }
 101
 102 #[derive(Diagnostic)]
 103 #[diag(codegen_ssa_incompatible_linking_modifiers)]
 104 pub struct IncompatibleLinkingModifiers;
 105
 106 #[derive(Diagnostic)]
 107 #[diag(codegen_ssa_add_native_library)]
 108 pub struct AddNativeLibrary {
 109     pub library_path: PathBuf,
 110     pub error: Error,
 111 }
 112
 113 #[derive(Diagnostic)]
 114 #[diag(codegen_ssa_multiple_external_func_decl)]
 115 pub struct MultipleExternalFuncDecl<'a> {
 116     #[primary_span]
 117     pub span: Span,
 118     pub function: Symbol,
 119     pub library_name: &'a str,
 120 }
 121
 122 #[derive(Diagnostic)]
 123 pub enum LinkRlibError {
 124     #[diag(codegen_ssa_rlib_missing_format)]
 125     MissingFormat,
 126
 127     #[diag(codegen_ssa_rlib_only_rmeta_found)]
 128     OnlyRmetaFound { crate_name: Symbol },
 129
 130     #[diag(codegen_ssa_rlib_not_found)]
 131     NotFound { crate_name: Symbol },
 132
 133     #[diag(codegen_ssa_rlib_incompatible_dependency_formats)]
 134     IncompatibleDependencyFormats { ty1: String, ty2: String, list1: String, list2: String },
 135 }
 136
 137 pub struct ThorinErrorWrapper(pub thorin::Error);
 138
 139 impl IntoDiagnostic<'_> for ThorinErrorWrapper {
 140     fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
 141         let mut diag;
 142         match self.0 {
 143             thorin::Error::ReadInput(_) => {
 144                 diag = handler.struct_err(fluent::codegen_ssa_thorin_read_input_failure);
 145                 diag
 146             }
 147             thorin::Error::ParseFileKind(_) => {
 148                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_input_file_kind);
 149                 diag
 150             }
 151             thorin::Error::ParseObjectFile(_) => {
 152                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_input_object_file);
 153                 diag
 154             }
 155             thorin::Error::ParseArchiveFile(_) => {
 156                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_input_archive_file);
 157                 diag
 158             }
 159             thorin::Error::ParseArchiveMember(_) => {
 160                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_archive_member);
 161                 diag
 162             }
 163             thorin::Error::InvalidInputKind => {
 164                 diag = handler.struct_err(fluent::codegen_ssa_thorin_invalid_input_kind);
 165                 diag
 166             }
 167             thorin::Error::DecompressData(_) => {
 168                 diag = handler.struct_err(fluent::codegen_ssa_thorin_decompress_data);
 169                 diag
 170             }
 171             thorin::Error::NamelessSection(_, offset) => {
 172                 diag = handler.struct_err(fluent::codegen_ssa_thorin_section_without_name);
 173                 diag.set_arg("offset", format!("0x{:08x}", offset));
 174                 diag
 175             }
 176             thorin::Error::RelocationWithInvalidSymbol(section, offset) => {
 177                 diag =
 178                     handler.struct_err(fluent::codegen_ssa_thorin_relocation_with_invalid_symbol);
 179                 diag.set_arg("section", section);
 180                 diag.set_arg("offset", format!("0x{:08x}", offset));
 181                 diag
 182             }
 183             thorin::Error::MultipleRelocations(section, offset) => {
 184                 diag = handler.struct_err(fluent::codegen_ssa_thorin_multiple_relocations);
 185                 diag.set_arg("section", section);
 186                 diag.set_arg("offset", format!("0x{:08x}", offset));
 187                 diag
 188             }
 189             thorin::Error::UnsupportedRelocation(section, offset) => {
 190                 diag = handler.struct_err(fluent::codegen_ssa_thorin_unsupported_relocation);
 191                 diag.set_arg("section", section);
 192                 diag.set_arg("offset", format!("0x{:08x}", offset));
 193                 diag
 194             }
 195             thorin::Error::MissingDwoName(id) => {
 196                 diag = handler.struct_err(fluent::codegen_ssa_thorin_missing_dwo_name);
 197                 diag.set_arg("id", format!("0x{:08x}", id));
 198                 diag
 199             }
 200             thorin::Error::NoCompilationUnits => {
 201                 diag = handler.struct_err(fluent::codegen_ssa_thorin_no_compilation_units);
 202                 diag
 203             }
 204             thorin::Error::NoDie => {
 205                 diag = handler.struct_err(fluent::codegen_ssa_thorin_no_die);
 206                 diag
 207             }
 208             thorin::Error::TopLevelDieNotUnit => {
 209                 diag = handler.struct_err(fluent::codegen_ssa_thorin_top_level_die_not_unit);
 210                 diag
 211             }
 212             thorin::Error::MissingRequiredSection(section) => {
 213                 diag = handler.struct_err(fluent::codegen_ssa_thorin_missing_required_section);
 214                 diag.set_arg("section", section);
 215                 diag
 216             }
 217             thorin::Error::ParseUnitAbbreviations(_) => {
 218                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit_abbreviations);
 219                 diag
 220             }
 221             thorin::Error::ParseUnitAttribute(_) => {
 222                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit_attribute);
 223                 diag
 224             }
 225             thorin::Error::ParseUnitHeader(_) => {
 226                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit_header);
 227                 diag
 228             }
 229             thorin::Error::ParseUnit(_) => {
 230                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_unit);
 231                 diag
 232             }
 233             thorin::Error::IncompatibleIndexVersion(section, format, actual) => {
 234                 diag = handler.struct_err(fluent::codegen_ssa_thorin_incompatible_index_version);
 235                 diag.set_arg("section", section);
 236                 diag.set_arg("actual", actual);
 237                 diag.set_arg("format", format);
 238                 diag
 239             }
 240             thorin::Error::OffsetAtIndex(_, index) => {
 241                 diag = handler.struct_err(fluent::codegen_ssa_thorin_offset_at_index);
 242                 diag.set_arg("index", index);
 243                 diag
 244             }
 245             thorin::Error::StrAtOffset(_, offset) => {
 246                 diag = handler.struct_err(fluent::codegen_ssa_thorin_str_at_offset);
 247                 diag.set_arg("offset", format!("0x{:08x}", offset));
 248                 diag
 249             }
 250             thorin::Error::ParseIndex(_, section) => {
 251                 diag = handler.struct_err(fluent::codegen_ssa_thorin_parse_index);
 252                 diag.set_arg("section", section);
 253                 diag
 254             }
 255             thorin::Error::UnitNotInIndex(unit) => {
 256                 diag = handler.struct_err(fluent::codegen_ssa_thorin_unit_not_in_index);
 257                 diag.set_arg("unit", format!("0x{:08x}", unit));
 258                 diag
 259             }
 260             thorin::Error::RowNotInIndex(_, row) => {
 261                 diag = handler.struct_err(fluent::codegen_ssa_thorin_row_not_in_index);
 262                 diag.set_arg("row", row);
 263                 diag
 264             }
 265             thorin::Error::SectionNotInRow => {
 266                 diag = handler.struct_err(fluent::codegen_ssa_thorin_section_not_in_row);
 267                 diag
 268             }
 269             thorin::Error::EmptyUnit(unit) => {
 270                 diag = handler.struct_err(fluent::codegen_ssa_thorin_empty_unit);
 271                 diag.set_arg("unit", format!("0x{:08x}", unit));
 272                 diag
 273             }
 274             thorin::Error::MultipleDebugInfoSection => {
 275                 diag = handler.struct_err(fluent::codegen_ssa_thorin_multiple_debug_info_section);
 276                 diag
 277             }
 278             thorin::Error::MultipleDebugTypesSection => {
 279                 diag = handler.struct_err(fluent::codegen_ssa_thorin_multiple_debug_types_section);
 280                 diag
 281             }
 282             thorin::Error::NotSplitUnit => {
 283                 diag = handler.struct_err(fluent::codegen_ssa_thorin_not_split_unit);
 284                 diag
 285             }
 286             thorin::Error::DuplicateUnit(unit) => {
 287                 diag = handler.struct_err(fluent::codegen_ssa_thorin_duplicate_unit);
 288                 diag.set_arg("unit", format!("0x{:08x}", unit));
 289                 diag
 290             }
 291             thorin::Error::MissingReferencedUnit(unit) => {
 292                 diag = handler.struct_err(fluent::codegen_ssa_thorin_missing_referenced_unit);
 293                 diag.set_arg("unit", format!("0x{:08x}", unit));
 294                 diag
 295             }
 296             thorin::Error::NoOutputObjectCreated => {
 297                 diag = handler.struct_err(fluent::codegen_ssa_thorin_not_output_object_created);
 298                 diag
 299             }
 300             thorin::Error::MixedInputEncodings => {
 301                 diag = handler.struct_err(fluent::codegen_ssa_thorin_mixed_input_encodings);
 302                 diag
 303             }
 304             thorin::Error::Io(e) => {
 305                 diag = handler.struct_err(fluent::codegen_ssa_thorin_io);
 306                 diag.set_arg("error", format!("{e}"));
 307                 diag
 308             }
 309             thorin::Error::ObjectRead(e) => {
 310                 diag = handler.struct_err(fluent::codegen_ssa_thorin_object_read);
 311                 diag.set_arg("error", format!("{e}"));
 312                 diag
 313             }
 314             thorin::Error::ObjectWrite(e) => {
 315                 diag = handler.struct_err(fluent::codegen_ssa_thorin_object_write);
 316                 diag.set_arg("error", format!("{e}"));
 317                 diag
 318             }
 319             thorin::Error::GimliRead(e) => {
 320                 diag = handler.struct_err(fluent::codegen_ssa_thorin_gimli_read);
 321                 diag.set_arg("error", format!("{e}"));
 322                 diag
 323             }
 324             thorin::Error::GimliWrite(e) => {
 325                 diag = handler.struct_err(fluent::codegen_ssa_thorin_gimli_write);
 326                 diag.set_arg("error", format!("{e}"));
 327                 diag
 328             }
 329             _ => unimplemented!("Untranslated thorin error"),
 330         }
 331     }
 332 }
 333
 334 pub struct LinkingFailed<'a> {
 335     pub linker_path: &'a PathBuf,
 336     pub exit_status: ExitStatus,
 337     pub command: &'a Command,
 338     pub escaped_output: &'a str,
 339 }
 340
 341 impl IntoDiagnostic<'_> for LinkingFailed<'_> {
 342     fn into_diagnostic(self, handler: &Handler) -> DiagnosticBuilder<'_, ErrorGuaranteed> {
 343         let mut diag = handler.struct_err(fluent::codegen_ssa_linking_failed);
 344         diag.set_arg("linker_path", format!("{}", self.linker_path.display()));
 345         diag.set_arg("exit_status", format!("{}", self.exit_status));
 346
 347         diag.note(format!("{:?}", self.command)).note(self.escaped_output);
 348
 349         // Trying to match an error from OS linkers
 350         // which by now we have no way to translate.
 351         if self.escaped_output.contains("undefined reference to") {
 352             diag.note(fluent::codegen_ssa_extern_funcs_not_found)
 353                 .note(fluent::codegen_ssa_specify_libraries_to_link)
 354                 .note(fluent::codegen_ssa_use_cargo_directive);
 355         }
 356         diag
 357     }
 358 }
 359
 360 #[derive(Diagnostic)]
 361 #[diag(codegen_ssa_link_exe_unexpected_error)]
 362 pub struct LinkExeUnexpectedError;
 363
 364 #[derive(Diagnostic)]
 365 #[diag(codegen_ssa_repair_vs_build_tools)]
 366 pub struct RepairVSBuildTools;
 367
 368 #[derive(Diagnostic)]
 369 #[diag(codegen_ssa_missing_cpp_build_tool_component)]
 370 pub struct MissingCppBuildToolComponent;
 371
 372 #[derive(Diagnostic)]
 373 #[diag(codegen_ssa_select_cpp_build_tool_workload)]
 374 pub struct SelectCppBuildToolWorkload;
 375
 376 #[derive(Diagnostic)]
 377 #[diag(codegen_ssa_visual_studio_not_installed)]
 378 pub struct VisualStudioNotInstalled;
 379
 380 #[derive(Diagnostic)]
 381 #[diag(codegen_ssa_linker_not_found)]
 382 #[note]
 383 pub struct LinkerNotFound {
 384     pub linker_path: PathBuf,
 385     pub error: Error,
 386 }
 387
 388 #[derive(Diagnostic)]
 389 #[diag(codegen_ssa_unable_to_exe_linker)]
 390 #[note]
 391 #[note(command_note)]
 392 pub struct UnableToExeLinker {
 393     pub linker_path: PathBuf,
 394     pub error: Error,
 395     pub command_formatted: String,
 396 }
 397
 398 #[derive(Diagnostic)]
 399 #[diag(codegen_ssa_msvc_missing_linker)]
 400 pub struct MsvcMissingLinker;
 401
 402 #[derive(Diagnostic)]
 403 #[diag(codegen_ssa_check_installed_visual_studio)]
 404 pub struct CheckInstalledVisualStudio;
 405
 406 #[derive(Diagnostic)]
 407 #[diag(codegen_ssa_unsufficient_vs_code_product)]
 408 pub struct UnsufficientVSCodeProduct;
 409
 410 #[derive(Diagnostic)]
 411 #[diag(codegen_ssa_processing_dymutil_failed)]
 412 #[note]
 413 pub struct ProcessingDymutilFailed {
 414     pub status: ExitStatus,
 415     pub output: String,
 416 }
 417
 418 #[derive(Diagnostic)]
 419 #[diag(codegen_ssa_unable_to_run_dsymutil)]
 420 #[note]
 421 pub struct UnableToRunDsymutil {
 422     pub error: Error,
 423 }
 424
 425 #[derive(Diagnostic)]
 426 #[diag(codegen_ssa_stripping_debu_info_failed)]
 427 #[note]
 428 pub struct StrippingDebugInfoFailed<'a> {
 429     pub util: &'a str,
 430     pub status: ExitStatus,
 431     pub output: String,
 432 }
 433
 434 #[derive(Diagnostic)]
 435 #[diag(codegen_ssa_unable_to_run)]
 436 pub struct UnableToRun<'a> {
 437     pub util: &'a str,
 438     pub error: Error,
 439 }
 440
 441 #[derive(Diagnostic)]
 442 #[diag(codegen_ssa_linker_file_stem)]
 443 pub struct LinkerFileStem;
 444
 445 #[derive(Diagnostic)]
 446 #[diag(codegen_ssa_static_library_native_artifacts)]
 447 pub struct StaticLibraryNativeArtifacts;
 448
 449 #[derive(Diagnostic)]
 450 #[diag(codegen_ssa_link_script_unavailable)]
 451 pub struct LinkScriptUnavailable;
 452
 453 #[derive(Diagnostic)]
 454 #[diag(codegen_ssa_link_script_write_failure)]
 455 pub struct LinkScriptWriteFailure {
 456     pub path: PathBuf,
 457     pub error: Error,
 458 }
 459
 460 #[derive(Diagnostic)]
 461 #[diag(codegen_ssa_failed_to_write)]
 462 pub struct FailedToWrite {
 463     pub path: PathBuf,
 464     pub error: Error,
 465 }
 466
 467 #[derive(Diagnostic)]
 468 #[diag(codegen_ssa_unable_to_write_debugger_visualizer)]
 469 pub struct UnableToWriteDebuggerVisualizer {
 470     pub path: PathBuf,
 471     pub error: Error,
 472 }
 473
 474 #[derive(Diagnostic)]
 475 #[diag(codegen_ssa_rlib_archive_build_failure)]
 476 pub struct RlibArchiveBuildFailure {
 477     pub error: Error,
 478 }
 479
 480 #[derive(Diagnostic)]
 481 #[diag(codegen_ssa_option_gcc_only)]
 482 pub struct OptionGccOnly;
 483
 484 #[derive(Diagnostic)]
 485 pub enum ExtractBundledLibsError<'a> {
 486     #[diag(codegen_ssa_extract_bundled_libs_open_file)]
 487     OpenFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
 488
 489     #[diag(codegen_ssa_extract_bundled_libs_mmap_file)]
 490     MmapFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
 491
 492     #[diag(codegen_ssa_extract_bundled_libs_parse_archive)]
 493     ParseArchive { rlib: &'a Path, error: Box<dyn std::error::Error> },
 494
 495     #[diag(codegen_ssa_extract_bundled_libs_read_entry)]
 496     ReadEntry { rlib: &'a Path, error: Box<dyn std::error::Error> },
 497
 498     #[diag(codegen_ssa_extract_bundled_libs_archive_member)]
 499     ArchiveMember { rlib: &'a Path, error: Box<dyn std::error::Error> },
 500
 501     #[diag(codegen_ssa_extract_bundled_libs_convert_name)]
 502     ConvertName { rlib: &'a Path, error: Box<dyn std::error::Error> },
 503
 504     #[diag(codegen_ssa_extract_bundled_libs_write_file)]
 505     WriteFile { rlib: &'a Path, error: Box<dyn std::error::Error> },
 506
 507     #[diag(codegen_ssa_extract_bundled_libs_write_file)]
 508     ExtractSection { rlib: &'a Path, error: Box<dyn std::error::Error> },
 509 }
 510
 511 #[derive(Diagnostic)]
 512 #[diag(codegen_ssa_unsupported_arch)]
 513 pub struct UnsupportedArch<'a> {
 514     pub arch: &'a str,
 515     pub os: &'a str,
 516 }
 517
 518 #[derive(Diagnostic)]
 519 pub enum AppleSdkRootError<'a> {
 520     #[diag(codegen_ssa_apple_sdk_error_sdk_path)]
 521     SdkPath { sdk_name: &'a str, error: Error },
 522 }
 523
 524 #[derive(Diagnostic)]
 525 #[diag(codegen_ssa_read_file)]
 526 pub struct ReadFileError {
 527     pub message: std::io::Error,
 528 }
 529
 530 #[derive(Diagnostic)]
 531 #[diag(codegen_ssa_unsupported_link_self_contained)]
 532 pub struct UnsupportedLinkSelfContained;
 533
 534 #[derive(Diagnostic)]
 535 #[diag(codegen_ssa_archive_build_failure)]
 536 // Public for rustc_codegen_llvm::back::archive
 537 pub struct ArchiveBuildFailure {
 538     pub error: std::io::Error,
 539 }
 540
 541 #[derive(Diagnostic)]
 542 #[diag(codegen_ssa_unknown_archive_kind)]
 543 // Public for rustc_codegen_llvm::back::archive
 544 pub struct UnknownArchiveKind<'a> {
 545     pub kind: &'a str,
 546 }
 547
 548 #[derive(Diagnostic)]
 549 #[diag(codegen_ssa_expected_used_symbol)]
 550 pub struct ExpectedUsedSymbol {
 551     #[primary_span]
 552     pub span: Span,
 553 }
 554
 555 #[derive(Diagnostic)]
 556 #[diag(codegen_ssa_multiple_main_functions)]
 557 #[help]
 558 pub struct MultipleMainFunctions {
 559     #[primary_span]
 560     pub span: Span,
 561 }
 562
 563 #[derive(Diagnostic)]
 564 #[diag(codegen_ssa_metadata_object_file_write)]
 565 pub struct MetadataObjectFileWrite {
 566     pub error: Error,
 567 }
 568
 569 #[derive(Diagnostic)]
 570 #[diag(codegen_ssa_invalid_windows_subsystem)]
 571 pub struct InvalidWindowsSubsystem {
 572     pub subsystem: Symbol,
 573 }
 574
 575 #[derive(Diagnostic)]
 576 #[diag(codegen_ssa_erroneous_constant)]
 577 pub struct ErroneousConstant {
 578     #[primary_span]
 579     pub span: Span,
 580 }
 581
 582 #[derive(Diagnostic)]
 583 #[diag(codegen_ssa_polymorphic_constant_too_generic)]
 584 pub struct PolymorphicConstantTooGeneric {
 585     #[primary_span]
 586     pub span: Span,
 587 }
 588
 589 #[derive(Diagnostic)]
 590 #[diag(codegen_ssa_shuffle_indices_evaluation)]
 591 pub struct ShuffleIndicesEvaluation {
 592     #[primary_span]
 593     pub span: Span,
 594 }
 595
 596 #[derive(Diagnostic)]
 597 #[diag(codegen_ssa_missing_memory_ordering)]
 598 pub struct MissingMemoryOrdering;
 599
 600 #[derive(Diagnostic)]
 601 #[diag(codegen_ssa_unknown_atomic_ordering)]
 602 pub struct UnknownAtomicOrdering;
 603
 604 #[derive(Diagnostic)]
 605 #[diag(codegen_ssa_atomic_compare_exchange)]
 606 pub struct AtomicCompareExchange;
 607
 608 #[derive(Diagnostic)]
 609 #[diag(codegen_ssa_unknown_atomic_operation)]
 610 pub struct UnknownAtomicOperation;
 611
 612 #[derive(Diagnostic)]
 613 pub enum InvalidMonomorphization<'tcx> {
 614     #[diag(codegen_ssa_invalid_monomorphization_basic_integer_type, code = "E0511")]
 615     BasicIntegerType {
 616         #[primary_span]
 617         span: Span,
 618         name: Symbol,
 619         ty: Ty<'tcx>,
 620     },
 621
 622     #[diag(codegen_ssa_invalid_monomorphization_basic_float_type, code = "E0511")]
 623     BasicFloatType {
 624         #[primary_span]
 625         span: Span,
 626         name: Symbol,
 627         ty: Ty<'tcx>,
 628     },
 629
 630     #[diag(codegen_ssa_invalid_monomorphization_float_to_int_unchecked, code = "E0511")]
 631     FloatToIntUnchecked {
 632         #[primary_span]
 633         span: Span,
 634         ty: Ty<'tcx>,
 635     },
 636
 637     #[diag(codegen_ssa_invalid_monomorphization_floating_point_vector, code = "E0511")]
 638     FloatingPointVector {
 639         #[primary_span]
 640         span: Span,
 641         name: Symbol,
 642         f_ty: FloatTy,
 643         in_ty: Ty<'tcx>,
 644     },
 645
 646     #[diag(codegen_ssa_invalid_monomorphization_floating_point_type, code = "E0511")]
 647     FloatingPointType {
 648         #[primary_span]
 649         span: Span,
 650         name: Symbol,
 651         in_ty: Ty<'tcx>,
 652     },
 653
 654     #[diag(codegen_ssa_invalid_monomorphization_unrecognized_intrinsic, code = "E0511")]
 655     UnrecognizedIntrinsic {
 656         #[primary_span]
 657         span: Span,
 658         name: Symbol,
 659     },
 660
 661     #[diag(codegen_ssa_invalid_monomorphization_simd_argument, code = "E0511")]
 662     SimdArgument {
 663         #[primary_span]
 664         span: Span,
 665         name: Symbol,
 666         ty: Ty<'tcx>,
 667     },
 668
 669     #[diag(codegen_ssa_invalid_monomorphization_simd_input, code = "E0511")]
 670     SimdInput {
 671         #[primary_span]
 672         span: Span,
 673         name: Symbol,
 674         ty: Ty<'tcx>,
 675     },
 676
 677     #[diag(codegen_ssa_invalid_monomorphization_simd_first, code = "E0511")]
 678     SimdFirst {
 679         #[primary_span]
 680         span: Span,
 681         name: Symbol,
 682         ty: Ty<'tcx>,
 683     },
 684
 685     #[diag(codegen_ssa_invalid_monomorphization_simd_second, code = "E0511")]
 686     SimdSecond {
 687         #[primary_span]
 688         span: Span,
 689         name: Symbol,
 690         ty: Ty<'tcx>,
 691     },
 692
 693     #[diag(codegen_ssa_invalid_monomorphization_simd_third, code = "E0511")]
 694     SimdThird {
 695         #[primary_span]
 696         span: Span,
 697         name: Symbol,
 698         ty: Ty<'tcx>,
 699     },
 700
 701     #[diag(codegen_ssa_invalid_monomorphization_simd_return, code = "E0511")]
 702     SimdReturn {
 703         #[primary_span]
 704         span: Span,
 705         name: Symbol,
 706         ty: Ty<'tcx>,
 707     },
 708
 709     #[diag(codegen_ssa_invalid_monomorphization_invalid_bitmask, code = "E0511")]
 710     InvalidBitmask {
 711         #[primary_span]
 712         span: Span,
 713         name: Symbol,
 714         mask_ty: Ty<'tcx>,
 715         expected_int_bits: u64,
 716         expected_bytes: u64,
 717     },
 718
 719     #[diag(codegen_ssa_invalid_monomorphization_return_length_input_type, code = "E0511")]
 720     ReturnLengthInputType {
 721         #[primary_span]
 722         span: Span,
 723         name: Symbol,
 724         in_len: u64,
 725         in_ty: Ty<'tcx>,
 726         ret_ty: Ty<'tcx>,
 727         out_len: u64,
 728     },
 729
 730     #[diag(codegen_ssa_invalid_monomorphization_second_argument_length, code = "E0511")]
 731     SecondArgumentLength {
 732         #[primary_span]
 733         span: Span,
 734         name: Symbol,
 735         in_len: u64,
 736         in_ty: Ty<'tcx>,
 737         arg_ty: Ty<'tcx>,
 738         out_len: u64,
 739     },
 740
 741     #[diag(codegen_ssa_invalid_monomorphization_third_argument_length, code = "E0511")]
 742     ThirdArgumentLength {
 743         #[primary_span]
 744         span: Span,
 745         name: Symbol,
 746         in_len: u64,
 747         in_ty: Ty<'tcx>,
 748         arg_ty: Ty<'tcx>,
 749         out_len: u64,
 750     },
 751
 752     #[diag(codegen_ssa_invalid_monomorphization_return_integer_type, code = "E0511")]
 753     ReturnIntegerType {
 754         #[primary_span]
 755         span: Span,
 756         name: Symbol,
 757         ret_ty: Ty<'tcx>,
 758         out_ty: Ty<'tcx>,
 759     },
 760
 761     #[diag(codegen_ssa_invalid_monomorphization_simd_shuffle, code = "E0511")]
 762     SimdShuffle {
 763         #[primary_span]
 764         span: Span,
 765         name: Symbol,
 766         ty: Ty<'tcx>,
 767     },
 768
 769     #[diag(codegen_ssa_invalid_monomorphization_return_length, code = "E0511")]
 770     ReturnLength {
 771         #[primary_span]
 772         span: Span,
 773         name: Symbol,
 774         in_len: u64,
 775         ret_ty: Ty<'tcx>,
 776         out_len: u64,
 777     },
 778
 779     #[diag(codegen_ssa_invalid_monomorphization_return_element, code = "E0511")]
 780     ReturnElement {
 781         #[primary_span]
 782         span: Span,
 783         name: Symbol,
 784         in_elem: Ty<'tcx>,
 785         in_ty: Ty<'tcx>,
 786         ret_ty: Ty<'tcx>,
 787         out_ty: Ty<'tcx>,
 788     },
 789
 790     #[diag(codegen_ssa_invalid_monomorphization_shuffle_index_not_constant, code = "E0511")]
 791     ShuffleIndexNotConstant {
 792         #[primary_span]
 793         span: Span,
 794         name: Symbol,
 795         arg_idx: u64,
 796     },
 797
 798     #[diag(codegen_ssa_invalid_monomorphization_shuffle_index_out_of_bounds, code = "E0511")]
 799     ShuffleIndexOutOfBounds {
 800         #[primary_span]
 801         span: Span,
 802         name: Symbol,
 803         arg_idx: u64,
 804         total_len: u128,
 805     },
 806
 807     #[diag(codegen_ssa_invalid_monomorphization_inserted_type, code = "E0511")]
 808     InsertedType {
 809         #[primary_span]
 810         span: Span,
 811         name: Symbol,
 812         in_elem: Ty<'tcx>,
 813         in_ty: Ty<'tcx>,
 814         out_ty: Ty<'tcx>,
 815     },
 816
 817     #[diag(codegen_ssa_invalid_monomorphization_return_type, code = "E0511")]
 818     ReturnType {
 819         #[primary_span]
 820         span: Span,
 821         name: Symbol,
 822         in_elem: Ty<'tcx>,
 823         in_ty: Ty<'tcx>,
 824         ret_ty: Ty<'tcx>,
 825     },
 826
 827     #[diag(codegen_ssa_invalid_monomorphization_expected_return_type, code = "E0511")]
 828     ExpectedReturnType {
 829         #[primary_span]
 830         span: Span,
 831         name: Symbol,
 832         in_ty: Ty<'tcx>,
 833         ret_ty: Ty<'tcx>,
 834     },
 835
 836     #[diag(codegen_ssa_invalid_monomorphization_mismatched_lengths, code = "E0511")]
 837     MismatchedLengths {
 838         #[primary_span]
 839         span: Span,
 840         name: Symbol,
 841         m_len: u64,
 842         v_len: u64,
 843     },
 844
 845     #[diag(codegen_ssa_invalid_monomorphization_mask_type, code = "E0511")]
 846     MaskType {
 847         #[primary_span]
 848         span: Span,
 849         name: Symbol,
 850         ty: Ty<'tcx>,
 851     },
 852
 853     #[diag(codegen_ssa_invalid_monomorphization_vector_argument, code = "E0511")]
 854     VectorArgument {
 855         #[primary_span]
 856         span: Span,
 857         name: Symbol,
 858         in_ty: Ty<'tcx>,
 859         in_elem: Ty<'tcx>,
 860     },
 861
 862     #[diag(codegen_ssa_invalid_monomorphization_cannot_return, code = "E0511")]
 863     CannotReturn {
 864         #[primary_span]
 865         span: Span,
 866         name: Symbol,
 867         ret_ty: Ty<'tcx>,
 868         expected_int_bits: u64,
 869         expected_bytes: u64,
 870     },
 871
 872     #[diag(codegen_ssa_invalid_monomorphization_expected_element_type, code = "E0511")]
 873     ExpectedElementType {
 874         #[primary_span]
 875         span: Span,
 876         name: Symbol,
 877         expected_element: Ty<'tcx>,
 878         second_arg: Ty<'tcx>,
 879         in_elem: Ty<'tcx>,
 880         in_ty: Ty<'tcx>,
 881         mutability: ExpectedPointerMutability,
 882     },
 883
 884     #[diag(codegen_ssa_invalid_monomorphization_third_arg_element_type, code = "E0511")]
 885     ThirdArgElementType {
 886         #[primary_span]
 887         span: Span,
 888         name: Symbol,
 889         expected_element: Ty<'tcx>,
 890         third_arg: Ty<'tcx>,
 891     },
 892
 893     #[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol_of_size, code = "E0511")]
 894     UnsupportedSymbolOfSize {
 895         #[primary_span]
 896         span: Span,
 897         name: Symbol,
 898         symbol: Symbol,
 899         in_ty: Ty<'tcx>,
 900         in_elem: Ty<'tcx>,
 901         size: u64,
 902         ret_ty: Ty<'tcx>,
 903     },
 904
 905     #[diag(codegen_ssa_invalid_monomorphization_unsupported_symbol, code = "E0511")]
 906     UnsupportedSymbol {
 907         #[primary_span]
 908         span: Span,
 909         name: Symbol,
 910         symbol: Symbol,
 911         in_ty: Ty<'tcx>,
 912         in_elem: Ty<'tcx>,
 913         ret_ty: Ty<'tcx>,
 914     },
 915
 916     #[diag(codegen_ssa_invalid_monomorphization_cast_fat_pointer, code = "E0511")]
 917     CastFatPointer {
 918         #[primary_span]
 919         span: Span,
 920         name: Symbol,
 921         ty: Ty<'tcx>,
 922     },
 923
 924     #[diag(codegen_ssa_invalid_monomorphization_expected_pointer, code = "E0511")]
 925     ExpectedPointer {
 926         #[primary_span]
 927         span: Span,
 928         name: Symbol,
 929         ty: Ty<'tcx>,
 930     },
 931
 932     #[diag(codegen_ssa_invalid_monomorphization_expected_usize, code = "E0511")]
 933     ExpectedUsize {
 934         #[primary_span]
 935         span: Span,
 936         name: Symbol,
 937         ty: Ty<'tcx>,
 938     },
 939
 940     #[diag(codegen_ssa_invalid_monomorphization_unsupported_cast, code = "E0511")]
 941     UnsupportedCast {
 942         #[primary_span]
 943         span: Span,
 944         name: Symbol,
 945         in_ty: Ty<'tcx>,
 946         in_elem: Ty<'tcx>,
 947         ret_ty: Ty<'tcx>,
 948         out_elem: Ty<'tcx>,
 949     },
 950
 951     #[diag(codegen_ssa_invalid_monomorphization_unsupported_operation, code = "E0511")]
 952     UnsupportedOperation {
 953         #[primary_span]
 954         span: Span,
 955         name: Symbol,
 956         in_ty: Ty<'tcx>,
 957         in_elem: Ty<'tcx>,
 958     },
 959
 960     #[diag(codegen_ssa_invalid_monomorphization_expected_vector_element_type, code = "E0511")]
 961     ExpectedVectorElementType {
 962         #[primary_span]
 963         span: Span,
 964         name: Symbol,
 965         expected_element: Ty<'tcx>,
 966         vector_type: Ty<'tcx>,
 967     },
 968 }
 969
 970 pub enum ExpectedPointerMutability {
 971     Mut,
 972     Not,
 973 }
 974
 975 impl IntoDiagnosticArg for ExpectedPointerMutability {
 976     fn into_diagnostic_arg(self) -> DiagnosticArgValue<'static> {
 977         match self {
 978             ExpectedPointerMutability::Mut => DiagnosticArgValue::Str(Cow::Borrowed("*mut")),
 979             ExpectedPointerMutability::Not => DiagnosticArgValue::Str(Cow::Borrowed("*_")),
 980         }
 981     }
 982 }