[rustllvm] Use report_fatal_error over llvm_unreachable

Robin Kruppe · Robin Kruppe · commit 296aa96deb7e · 2017-11-20T17:47:29.000+01:00
This makes it more robust when assertions are disabled, crashing instead of causing UB. Also introduces a tidy check to enforce this rule, which in turn necessitated making tidy run on src/rustllvm. Fixes #44020
diff --git a/src/rustllvm/ArchiveWrapper.cpp b/src/rustllvm/ArchiveWrapper.cpp
@@ -66,7 +66,7 @@ static Archive::Kind fromRust(LLVMRustArchiveKind Kind) {
   case LLVMRustArchiveKind::COFF:
     return Archive::K_COFF;
   default:
-    llvm_unreachable("Bad ArchiveKind.");
+    report_fatal_error("Bad ArchiveKind.");
   }
 }
 
diff --git a/src/rustllvm/PassWrapper.cpp b/src/rustllvm/PassWrapper.cpp
@@ -235,7 +235,7 @@ static CodeModel::Model fromRust(LLVMRustCodeModel Model) {
   case LLVMRustCodeModel::Large:
     return CodeModel::Large;
   default:
-    llvm_unreachable("Bad CodeModel.");
+    report_fatal_error("Bad CodeModel.");
   }
 }
 
@@ -258,7 +258,7 @@ static CodeGenOpt::Level fromRust(LLVMRustCodeGenOptLevel Level) {
   case LLVMRustCodeGenOptLevel::Aggressive:
     return CodeGenOpt::Aggressive;
   default:
-    llvm_unreachable("Bad CodeGenOptLevel.");
+    report_fatal_error("Bad CodeGenOptLevel.");
   }
 }
 
@@ -302,7 +302,7 @@ static Optional<Reloc::Model> fromRust(LLVMRustRelocMode RustReloc) {
     break;
 #endif
   }
-  llvm_unreachable("Bad RelocModel.");
+  report_fatal_error("Bad RelocModel.");
 }
 
 #if LLVM_RUSTLLVM
@@ -511,7 +511,7 @@ static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) {
   case LLVMRustFileType::ObjectFile:
     return TargetMachine::CGFT_ObjectFile;
   default:
-    llvm_unreachable("Bad FileType.");
+    report_fatal_error("Bad FileType.");
   }
 }
 
@@ -1197,7 +1197,7 @@ extern "C" bool
 LLVMRustWriteThinBitcodeToFile(LLVMPassManagerRef PMR,
                                LLVMModuleRef M,
                                const char *BcFile) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 struct LLVMRustThinLTOData {
@@ -1211,62 +1211,62 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,
                           int num_modules,
                           const char **preserved_symbols,
                           int num_symbols) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" bool
 LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" bool
 LLVMRustPrepareThinLTOResolveWeak(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" bool
 LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" bool
 LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" void
 LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 struct LLVMRustThinLTOBuffer {
 };
 
 extern "C" LLVMRustThinLTOBuffer*
 LLVMRustThinLTOBufferCreate(LLVMModuleRef M) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" void
 LLVMRustThinLTOBufferFree(LLVMRustThinLTOBuffer *Buffer) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" const void*
 LLVMRustThinLTOBufferPtr(const LLVMRustThinLTOBuffer *Buffer) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" size_t
 LLVMRustThinLTOBufferLen(const LLVMRustThinLTOBuffer *Buffer) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 
 extern "C" LLVMModuleRef
 LLVMRustParseBitcodeForThinLTO(LLVMContextRef Context,
                                const char *data,
                                size_t len,
                                const char *identifier) {
-  llvm_unreachable("ThinLTO not available");
+  report_fatal_error("ThinLTO not available");
 }
 #endif // LLVM_VERSION_GE(4, 0)
diff --git a/src/rustllvm/RustWrapper.cpp b/src/rustllvm/RustWrapper.cpp
@@ -54,7 +54,7 @@ static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {
     return AtomicOrdering::SequentiallyConsistent;
   }
 
-  llvm_unreachable("Invalid LLVMAtomicOrdering value!");
+  report_fatal_error("Invalid LLVMAtomicOrdering value!");
 }
 
 static LLVM_THREAD_LOCAL char *LastError;
@@ -161,7 +161,7 @@ static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {
   case SanitizeMemory:
     return Attribute::SanitizeMemory;
   }
-  llvm_unreachable("bad AttributeKind");
+  report_fatal_error("bad AttributeKind");
 }
 
 extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned Index,
@@ -356,7 +356,7 @@ static SyncScope::ID fromRust(LLVMRustSynchronizationScope Scope) {
   case LLVMRustSynchronizationScope::CrossThread:
     return SyncScope::System;
   default:
-    llvm_unreachable("bad SynchronizationScope.");
+    report_fatal_error("bad SynchronizationScope.");
   }
 }
 #else
@@ -367,7 +367,7 @@ static SynchronizationScope fromRust(LLVMRustSynchronizationScope Scope) {
   case LLVMRustSynchronizationScope::CrossThread:
     return CrossThread;
   default:
-    llvm_unreachable("bad SynchronizationScope.");
+    report_fatal_error("bad SynchronizationScope.");
   }
 }
 #endif
@@ -397,7 +397,7 @@ static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {
   case LLVMRustAsmDialect::Intel:
     return InlineAsm::AD_Intel;
   default:
-    llvm_unreachable("bad AsmDialect.");
+    report_fatal_error("bad AsmDialect.");
   }
 }
 
@@ -748,7 +748,7 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(
         unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)
 #if LLVM_VERSION_GE(4, 0)
         ,
-	AlignInBits
+  AlignInBits
 #endif
         ));
   } else {
@@ -1149,7 +1149,7 @@ extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {
     return LLVMTokenTypeKind;
 #endif
   }
-  llvm_unreachable("Unhandled TypeID.");
+  report_fatal_error("Unhandled TypeID.");
 }
 
 extern "C" void LLVMRustWriteDebugLocToString(LLVMContextRef C,
@@ -1370,7 +1370,7 @@ static LLVMRustLinkage toRust(LLVMLinkage Linkage) {
   case LLVMCommonLinkage:
     return LLVMRustLinkage::CommonLinkage;
   default:
-    llvm_unreachable("Invalid LLVMRustLinkage value!");
+    report_fatal_error("Invalid LLVMRustLinkage value!");
   }
 }
 
@@ -1399,7 +1399,7 @@ static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {
   case LLVMRustLinkage::CommonLinkage:
     return LLVMCommonLinkage;
   }
-  llvm_unreachable("Invalid LLVMRustLinkage value!");
+  report_fatal_error("Invalid LLVMRustLinkage value!");
 }
 
 extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {
@@ -1447,7 +1447,7 @@ static LLVMRustVisibility toRust(LLVMVisibility Vis) {
   case LLVMProtectedVisibility:
     return LLVMRustVisibility::Protected;
   }
-  llvm_unreachable("Invalid LLVMRustVisibility value!");
+  report_fatal_error("Invalid LLVMRustVisibility value!");
 }
 
 static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
@@ -1459,7 +1459,7 @@ static LLVMVisibility fromRust(LLVMRustVisibility Vis) {
   case LLVMRustVisibility::Protected:
     return LLVMProtectedVisibility;
   }
-  llvm_unreachable("Invalid LLVMRustVisibility value!");
+  report_fatal_error("Invalid LLVMRustVisibility value!");
 }
 
 extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {
diff --git a/src/tools/tidy/src/lib.rs b/src/tools/tidy/src/lib.rs
@@ -57,7 +57,6 @@ fn filter_dirs(path: &Path) -> bool {
         "src/libbacktrace",
         "src/libcompiler_builtins",
         "src/compiler-rt",
-        "src/rustllvm",
         "src/liblibc",
         "src/vendor",
         "src/rt/hoedown",
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
@@ -50,6 +50,11 @@ const UNEXPLAINED_IGNORE_DOCTEST_INFO: &str = r#"unexplained "```ignore" doctest
 
 "#;
 
+const LLVM_UNREACHABLE_INFO: &str = r"\
+C++ code used llvm_unreachable, which triggers undefined behavior
+when executed when assertions are disabled.
+Use llvm::report_fatal_error for increased robustness.";
+
 /// Parser states for line_is_url.
 #[derive(PartialEq)]
 #[allow(non_camel_case_types)]
@@ -108,7 +113,7 @@ pub fn check(path: &Path, bad: &mut bool) {
     let mut contents = String::new();
     super::walk(path, &mut super::filter_dirs, &mut |file| {
         let filename = file.file_name().unwrap().to_string_lossy();
-        let extensions = [".rs", ".py", ".js", ".sh", ".c", ".h"];
+        let extensions = [".rs", ".py", ".js", ".sh", ".c", ".cpp", ".h"];
         if extensions.iter().all(|e| !filename.ends_with(e)) ||
            filename.starts_with(".#") {
             return
@@ -153,6 +158,9 @@ pub fn check(path: &Path, bad: &mut bool) {
             if line.ends_with("```ignore") || line.ends_with("```rust,ignore") {
                 err(UNEXPLAINED_IGNORE_DOCTEST_INFO);
             }
+            if filename.ends_with(".cpp") && line.contains("llvm_unreachable") {
+                err(LLVM_UNREACHABLE_INFO);
+            }
         }
         if !licenseck(file, &contents) {
             tidy_error!(bad, "{}: incorrect license", file.display());

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ static Archive::Kind fromRust(LLVMRustArchiveKind Kind) {`
`66`	`66`	`case LLVMRustArchiveKind::COFF:`
`67`	`67`	`return Archive::K_COFF;`
`68`	`68`	`default:`
`69`		`- llvm_unreachable("Bad ArchiveKind.");`
	`69`	`+ report_fatal_error("Bad ArchiveKind.");`
`70`	`70`	`}`
`71`	`71`	`}`
`72`	`72`
Original file line number	Diff line number	Diff line change
`@@ -235,7 +235,7 @@ static CodeModel::Model fromRust(LLVMRustCodeModel Model) {`
`235`	`235`	`case LLVMRustCodeModel::Large:`
`236`	`236`	`return CodeModel::Large;`
`237`	`237`	`default:`
`238`		`- llvm_unreachable("Bad CodeModel.");`
	`238`	`+ report_fatal_error("Bad CodeModel.");`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`
`@@ -258,7 +258,7 @@ static CodeGenOpt::Level fromRust(LLVMRustCodeGenOptLevel Level) {`
`258`	`258`	`case LLVMRustCodeGenOptLevel::Aggressive:`
`259`	`259`	`return CodeGenOpt::Aggressive;`
`260`	`260`	`default:`
`261`		`- llvm_unreachable("Bad CodeGenOptLevel.");`
	`261`	`+ report_fatal_error("Bad CodeGenOptLevel.");`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`@@ -302,7 +302,7 @@ static Optional<Reloc::Model> fromRust(LLVMRustRelocMode RustReloc) {`
`302`	`302`	`break;`
`303`	`303`	`#endif`
`304`	`304`	`}`
`305`		`- llvm_unreachable("Bad RelocModel.");`
	`305`	`+ report_fatal_error("Bad RelocModel.");`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`#if LLVM_RUSTLLVM`
`@@ -511,7 +511,7 @@ static TargetMachine::CodeGenFileType fromRust(LLVMRustFileType Type) {`
`511`	`511`	`case LLVMRustFileType::ObjectFile:`
`512`	`512`	`return TargetMachine::CGFT_ObjectFile;`
`513`	`513`	`default:`
`514`		`- llvm_unreachable("Bad FileType.");`
	`514`	`+ report_fatal_error("Bad FileType.");`
`515`	`515`	`}`
`516`	`516`	`}`
`517`	`517`
`@@ -1197,7 +1197,7 @@ extern "C" bool`
`1197`	`1197`	`LLVMRustWriteThinBitcodeToFile(LLVMPassManagerRef PMR,`
`1198`	`1198`	`LLVMModuleRef M,`
`1199`	`1199`	`const char *BcFile) {`
`1200`		`- llvm_unreachable("ThinLTO not available");`
	`1200`	`+ report_fatal_error("ThinLTO not available");`
`1201`	`1201`	`}`
`1202`	`1202`
`1203`	`1203`	`struct LLVMRustThinLTOData {`
`@@ -1211,62 +1211,62 @@ LLVMRustCreateThinLTOData(LLVMRustThinLTOModule *modules,`
`1211`	`1211`	`int num_modules,`
`1212`	`1212`	`const char **preserved_symbols,`
`1213`	`1213`	`int num_symbols) {`
`1214`		`- llvm_unreachable("ThinLTO not available");`
	`1214`	`+ report_fatal_error("ThinLTO not available");`
`1215`	`1215`	`}`
`1216`	`1216`
`1217`	`1217`	`extern "C" bool`
`1218`	`1218`	`LLVMRustPrepareThinLTORename(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {`
`1219`		`- llvm_unreachable("ThinLTO not available");`
	`1219`	`+ report_fatal_error("ThinLTO not available");`
`1220`	`1220`	`}`
`1221`	`1221`
`1222`	`1222`	`extern "C" bool`
`1223`	`1223`	`LLVMRustPrepareThinLTOResolveWeak(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {`
`1224`		`- llvm_unreachable("ThinLTO not available");`
	`1224`	`+ report_fatal_error("ThinLTO not available");`
`1225`	`1225`	`}`
`1226`	`1226`
`1227`	`1227`	`extern "C" bool`
`1228`	`1228`	`LLVMRustPrepareThinLTOInternalize(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {`
`1229`		`- llvm_unreachable("ThinLTO not available");`
	`1229`	`+ report_fatal_error("ThinLTO not available");`
`1230`	`1230`	`}`
`1231`	`1231`
`1232`	`1232`	`extern "C" bool`
`1233`	`1233`	`LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data, LLVMModuleRef M) {`
`1234`		`- llvm_unreachable("ThinLTO not available");`
	`1234`	`+ report_fatal_error("ThinLTO not available");`
`1235`	`1235`	`}`
`1236`	`1236`
`1237`	`1237`	`extern "C" void`
`1238`	`1238`	`LLVMRustFreeThinLTOData(LLVMRustThinLTOData *Data) {`
`1239`		`- llvm_unreachable("ThinLTO not available");`
	`1239`	`+ report_fatal_error("ThinLTO not available");`
`1240`	`1240`	`}`
`1241`	`1241`
`1242`	`1242`	`struct LLVMRustThinLTOBuffer {`
`1243`	`1243`	`};`
`1244`	`1244`
`1245`	`1245`	`extern "C" LLVMRustThinLTOBuffer*`
`1246`	`1246`	`LLVMRustThinLTOBufferCreate(LLVMModuleRef M) {`
`1247`		`- llvm_unreachable("ThinLTO not available");`
	`1247`	`+ report_fatal_error("ThinLTO not available");`
`1248`	`1248`	`}`
`1249`	`1249`
`1250`	`1250`	`extern "C" void`
`1251`	`1251`	`LLVMRustThinLTOBufferFree(LLVMRustThinLTOBuffer *Buffer) {`
`1252`		`- llvm_unreachable("ThinLTO not available");`
	`1252`	`+ report_fatal_error("ThinLTO not available");`
`1253`	`1253`	`}`
`1254`	`1254`
`1255`	`1255`	`extern "C" const void*`
`1256`	`1256`	`LLVMRustThinLTOBufferPtr(const LLVMRustThinLTOBuffer *Buffer) {`
`1257`		`- llvm_unreachable("ThinLTO not available");`
	`1257`	`+ report_fatal_error("ThinLTO not available");`
`1258`	`1258`	`}`
`1259`	`1259`
`1260`	`1260`	`extern "C" size_t`
`1261`	`1261`	`LLVMRustThinLTOBufferLen(const LLVMRustThinLTOBuffer *Buffer) {`
`1262`		`- llvm_unreachable("ThinLTO not available");`
	`1262`	`+ report_fatal_error("ThinLTO not available");`
`1263`	`1263`	`}`
`1264`	`1264`
`1265`	`1265`	`extern "C" LLVMModuleRef`
`1266`	`1266`	`LLVMRustParseBitcodeForThinLTO(LLVMContextRef Context,`
`1267`	`1267`	`const char *data,`
`1268`	`1268`	`size_t len,`
`1269`	`1269`	`const char *identifier) {`
`1270`		`- llvm_unreachable("ThinLTO not available");`
	`1270`	`+ report_fatal_error("ThinLTO not available");`
`1271`	`1271`	`}`
`1272`	`1272`	`#endif // LLVM_VERSION_GE(4, 0)`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ static AtomicOrdering fromRust(LLVMAtomicOrdering Ordering) {`
`54`	`54`	`return AtomicOrdering::SequentiallyConsistent;`
`55`	`55`	`}`
`56`	`56`
`57`		`- llvm_unreachable("Invalid LLVMAtomicOrdering value!");`
	`57`	`+ report_fatal_error("Invalid LLVMAtomicOrdering value!");`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`static LLVM_THREAD_LOCAL char *LastError;`
`@@ -161,7 +161,7 @@ static Attribute::AttrKind fromRust(LLVMRustAttribute Kind) {`
`161`	`161`	`case SanitizeMemory:`
`162`	`162`	`return Attribute::SanitizeMemory;`
`163`	`163`	`}`
`164`		`- llvm_unreachable("bad AttributeKind");`
	`164`	`+ report_fatal_error("bad AttributeKind");`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`extern "C" void LLVMRustAddCallSiteAttribute(LLVMValueRef Instr, unsigned Index,`
`@@ -356,7 +356,7 @@ static SyncScope::ID fromRust(LLVMRustSynchronizationScope Scope) {`
`356`	`356`	`case LLVMRustSynchronizationScope::CrossThread:`
`357`	`357`	`return SyncScope::System;`
`358`	`358`	`default:`
`359`		`- llvm_unreachable("bad SynchronizationScope.");`
	`359`	`+ report_fatal_error("bad SynchronizationScope.");`
`360`	`360`	`}`
`361`	`361`	`}`
`362`	`362`	`#else`
`@@ -367,7 +367,7 @@ static SynchronizationScope fromRust(LLVMRustSynchronizationScope Scope) {`
`367`	`367`	`case LLVMRustSynchronizationScope::CrossThread:`
`368`	`368`	`return CrossThread;`
`369`	`369`	`default:`
`370`		`- llvm_unreachable("bad SynchronizationScope.");`
	`370`	`+ report_fatal_error("bad SynchronizationScope.");`
`371`	`371`	`}`
`372`	`372`	`}`
`373`	`373`	`#endif`
`@@ -397,7 +397,7 @@ static InlineAsm::AsmDialect fromRust(LLVMRustAsmDialect Dialect) {`
`397`	`397`	`case LLVMRustAsmDialect::Intel:`
`398`	`398`	`return InlineAsm::AD_Intel;`
`399`	`399`	`default:`
`400`		`- llvm_unreachable("bad AsmDialect.");`
	`400`	`+ report_fatal_error("bad AsmDialect.");`
`401`	`401`	`}`
`402`	`402`	`}`
`403`	`403`
`@@ -748,7 +748,7 @@ extern "C" LLVMMetadataRef LLVMRustDIBuilderCreateVariable(`
`748`	`748`	`unwrapDI<DIType>(Ty), AlwaysPreserve, fromRust(Flags)`
`749`	`749`	`#if LLVM_VERSION_GE(4, 0)`
`750`	`750`	`,`
`751`		`- AlignInBits`
	`751`	`+ AlignInBits`
`752`	`752`	`#endif`
`753`	`753`	`));`
`754`	`754`	`} else {`
`@@ -1149,7 +1149,7 @@ extern "C" LLVMTypeKind LLVMRustGetTypeKind(LLVMTypeRef Ty) {`
`1149`	`1149`	`return LLVMTokenTypeKind;`
`1150`	`1150`	`#endif`
`1151`	`1151`	`}`
`1152`		`- llvm_unreachable("Unhandled TypeID.");`
	`1152`	`+ report_fatal_error("Unhandled TypeID.");`
`1153`	`1153`	`}`
`1154`	`1154`
`1155`	`1155`	`extern "C" void LLVMRustWriteDebugLocToString(LLVMContextRef C,`
`@@ -1370,7 +1370,7 @@ static LLVMRustLinkage toRust(LLVMLinkage Linkage) {`
`1370`	`1370`	`case LLVMCommonLinkage:`
`1371`	`1371`	`return LLVMRustLinkage::CommonLinkage;`
`1372`	`1372`	`default:`
`1373`		`- llvm_unreachable("Invalid LLVMRustLinkage value!");`
	`1373`	`+ report_fatal_error("Invalid LLVMRustLinkage value!");`
`1374`	`1374`	`}`
`1375`	`1375`	`}`
`1376`	`1376`
`@@ -1399,7 +1399,7 @@ static LLVMLinkage fromRust(LLVMRustLinkage Linkage) {`
`1399`	`1399`	`case LLVMRustLinkage::CommonLinkage:`
`1400`	`1400`	`return LLVMCommonLinkage;`
`1401`	`1401`	`}`
`1402`		`- llvm_unreachable("Invalid LLVMRustLinkage value!");`
	`1402`	`+ report_fatal_error("Invalid LLVMRustLinkage value!");`
`1403`	`1403`	`}`
`1404`	`1404`
`1405`	`1405`	`extern "C" LLVMRustLinkage LLVMRustGetLinkage(LLVMValueRef V) {`
`@@ -1447,7 +1447,7 @@ static LLVMRustVisibility toRust(LLVMVisibility Vis) {`
`1447`	`1447`	`case LLVMProtectedVisibility:`
`1448`	`1448`	`return LLVMRustVisibility::Protected;`
`1449`	`1449`	`}`
`1450`		`- llvm_unreachable("Invalid LLVMRustVisibility value!");`
	`1450`	`+ report_fatal_error("Invalid LLVMRustVisibility value!");`
`1451`	`1451`	`}`
`1452`	`1452`
`1453`	`1453`	`static LLVMVisibility fromRust(LLVMRustVisibility Vis) {`
`@@ -1459,7 +1459,7 @@ static LLVMVisibility fromRust(LLVMRustVisibility Vis) {`
`1459`	`1459`	`case LLVMRustVisibility::Protected:`
`1460`	`1460`	`return LLVMProtectedVisibility;`
`1461`	`1461`	`}`
`1462`		`- llvm_unreachable("Invalid LLVMRustVisibility value!");`
	`1462`	`+ report_fatal_error("Invalid LLVMRustVisibility value!");`
`1463`	`1463`	`}`
`1464`	`1464`
`1465`	`1465`	`extern "C" LLVMRustVisibility LLVMRustGetVisibility(LLVMValueRef V) {`