[Draft] Sanitize clang target triple

[serge-sans-paille]

Summary

Warn when meeting an unknown vendor / os / environment

[serge-sans-paille]

This is a tentative patch for https://discourse.llvm.org/t/linking-without-gcc-on-gnu-linux/66428/3 unfortunately it appears that many triples are not recognized while widely used (at least in the CI) for instance aarch64-arm-none-eabi is used a lot in the testsuite but arm is not a registered vendor... Any thoughts?

clang/include/clang/Basic/DiagnosticCommonKinds.td

 }
 
 // Sema && Serialization
 def warn_dup_category_def : Warning<
   "duplicate definition of category %1 on interface %0">;
 
 // Targets
 
+def warn_target_unknown_triple_components : Warning<
+  "unknown triple %0 '%1'">;
 def err_target_unknown_triple : Error<
   "unknown target triple '%0', please use -triple or -arch">;
 def err_target_unknown_cpu : Error<"unknown target CPU '%0'">;
 def note_valid_options : Note<"valid target CPU values are: %0">;
 def err_target_unsupported_cpu_for_micromips : Error<
   "micromips is not supported for target CPU '%0'">;
 def err_target_unknown_abi : Error<"unknown target ABI '%0'">;
 def err_target_unsupported_abi : Error<"ABI '%0' is not supported on CPU '%1'">;

clang/lib/Basic/Targets.cpp

case llvm::Triple::loongarch64:
     default:
       return new LoongArch64TargetInfo(Triple, Opts);
     }
   }
 }
 } // namespace targets
 } // namespace clang
 
+
+static
+void CheckTriple(DiagnosticsEngine &Diags, llvm::Triple const& Triple)
+{
+  auto IsUnrecognizedValue = [](StringRef Value) {
+    return !Value.empty() && Value != "unknown" && Value != "none";
+  };
+
+  if (Triple.getVendor() == llvm::Triple::UnknownVendor &&
+      IsUnrecognizedValue(Triple.getVendorName()))
+    Diags.Report(diag::warn_target_unknown_triple_components) << "vendor" << Triple.getVendorName();
+  if (Triple.getOS() == llvm::Triple::UnknownOS &&
+      IsUnrecognizedValue(Triple.getOSName()))
+    Diags.Report(diag::warn_target_unknown_triple_components) << "os" << Triple.getOSName();
+  if (Triple.getEnvironment() == llvm::Triple::UnknownEnvironment &&
+      IsUnrecognizedValue(Triple.getEnvironmentName()))
+    Diags.Report(diag::warn_target_unknown_triple_components) << "environment" << Triple.getEnvironmentName();
+}
+
 using namespace clang::targets;
 /// CreateTargetInfo - Return the target info object for the specified target
 /// options.
 TargetInfo *
 TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
                              const std::shared_ptr<TargetOptions> &Opts) {
   llvm::Triple Triple(Opts->Triple);
 
   // Construct the target
   std::unique_ptr<TargetInfo> Target(AllocateTarget(Triple, *Opts));
   if (!Target) {
     Diags.Report(diag::err_target_unknown_triple) << Triple.str();
     return nullptr;
   }
   Target->TargetOpts = Opts;
 
+  // Check after we created the target has it only raises warnings.
+  CheckTriple(Diags, Triple);
+
   // Set the target CPU if specified.
   if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {
     Diags.Report(diag::err_target_unknown_cpu) << Opts->CPU;
     SmallVector<StringRef, 32> ValidList;
     Target->fillValidCPUList(ValidList);
     if (!ValidList.empty())
       Diags.Report(diag::note_valid_options) << llvm::join(ValidList, ", ");
     return nullptr;