Add X86 Support to ValidCPUList (enabling march notes)

[erichkeane]

Summary

A followup to: https://reviews.llvm.org/D42978
This patch adds X86 and X86_64 support for
enabling the march notes.

[erichkeane]

removed careless newline, also rebases off ARM patch.

[craig.topper]

LGTM

[Hahnfeld]

lib/Basic/Targets/X86.cpp

1670–1672 ↗

(On Diff #133443)

checkCPUKind() doesn't define PROC_ALIAS so I don't think it can handle the values?

test/Misc/target-invalid-cpu-note.c

11 ↗

(On Diff #133443)

If we really want to check all these values (does any other test do it? I don't really get the value) this line needs to be split, it's way too long.

[Hahnfeld]

lib/Basic/Targets/X86.cpp

1670–1672 ↗

(On Diff #133443)

Never mind, the enum value is enough. Silly me :-/

[erichkeane]

Cleaned up the test as suggested.

cfe/trunk/lib/Basic/Targets/X86.h

if (getTriple().getArch() == llvm::Triple::x86 &&
       return "no-mmx";
     return "";
   }
 
   bool isValidCPUName(StringRef Name) const override {
     return checkCPUKind(getCPUKind(Name));
   }
 
+  void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
+
   bool setCPU(const std::string &Name) override {
     return checkCPUKind(CPU = getCPUKind(Name));
   }
 
   bool supportsMultiVersioning() const override {
     return getTriple().isOSBinFormatELF();
   }
   unsigned multiVersionSortPriority(StringRef Name) const override;

cfe/trunk/lib/Basic/Targets/X86.cpp

 // This file implements X86 TargetInfo objects.
 //
 //===----------------------------------------------------------------------===//
 
 #include "X86.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/TargetBuiltins.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/TargetParser.h"
 
 namespace clang {
 namespace targets {
 
 const Builtin::Info BuiltinInfoX86[] = {
std::string X86TargetInfo::convertConstraint(const char *&Constraint) const {
   default:
     return std::string(1, *Constraint);
   }
 }
 
 bool X86TargetInfo::checkCPUKind(CPUKind Kind) const {
   // Perform any per-CPU checks necessary to determine if this CPU is
   // acceptable.
-  // FIXME: This results in terrible diagnostics. Clang just says the CPU is
-  // invalid without explaining *why*.
   switch (Kind) {
   case CK_Generic:
     // No processor selected!
     return false;
 #define PROC(ENUM, STRING, IS64BIT)                                            \
   case CK_##ENUM:                                                              \
     return IS64BIT || getTriple().getArch() == llvm::Triple::x86;
 #include "clang/Basic/X86Target.def"
   }
   llvm_unreachable("Unhandled CPU kind");
 }
 
+void X86TargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {
+#define PROC(ENUM, STRING, IS64BIT)                                            \
+  if (IS64BIT || getTriple().getArch() == llvm::Triple::x86)                   \
+    Values.emplace_back(STRING);
+  // Go through CPUKind checking to ensure that the alias is de-aliased and 
+  // 64 bit-ness is checked.
+#define PROC_ALIAS(ENUM, ALIAS)                                                \
+  if (checkCPUKind(getCPUKind(ALIAS)))                                         \
+    Values.emplace_back(ALIAS);
+#include "clang/Basic/X86Target.def"
+}
+
 X86TargetInfo::CPUKind X86TargetInfo::getCPUKind(StringRef CPU) const {
   return llvm::StringSwitch<CPUKind>(CPU)
 #define PROC(ENUM, STRING, IS64BIT) .Case(STRING, CK_##ENUM)
 #define PROC_ALIAS(ENUM, ALIAS) .Case(ALIAS, CK_##ENUM)
 #include "clang/Basic/X86Target.def"
       .Default(CK_Generic);
 }