[TextAPI] Prefix all architecture enums to fix the build on i386.

[ributzka]

Summary

This changes the Architecture enum to use a prefix (AK_) to prevent the preprocessor from replacing i386 with 1 when building llvm/clang for i386.

[mstorsjo]

LGTM, thanks!

llvm/trunk/include/llvm/TextAPI/MachO/Architecture.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace MachO {
 
 /// Defines the architecture slices that are supported by Text-based Stub files.
-enum class Architecture : uint8_t {
-#define ARCHINFO(Arch, Type, SubType) Arch,
+enum Architecture : uint8_t {
+#define ARCHINFO(Arch, Type, SubType) AK_##Arch,
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
-  unknown, // this has to go last.
+  AK_unknown, // this has to go last.
 };
 
 /// Convert a CPU Type and Subtype pair to an architecture slice.
 Architecture getArchitectureFromCpuType(uint32_t CPUType, uint32_t CPUSubType);
 
 /// Convert a name to an architecture slice.
 Architecture getArchitectureFromName(StringRef Name);
 

llvm/trunk/include/llvm/TextAPI/MachO/ArchitectureSet.h

 
 public:
   constexpr ArchitectureSet() = default;
   constexpr ArchitectureSet(ArchSetType Raw) : ArchSet(Raw) {}
   ArchitectureSet(Architecture Arch) : ArchitectureSet() { set(Arch); }
   ArchitectureSet(const std::vector<Architecture> &Archs);
 
   void set(Architecture Arch) {
-    if (Arch == Architecture::unknown)
+    if (Arch == AK_unknown)
       return;
     ArchSet |= 1U << static_cast<int>(Arch);
   }
 
   void clear(Architecture Arch) { ArchSet &= ~(1U << static_cast<int>(Arch)); }
 
   bool has(Architecture Arch) const {
     return ArchSet & (1U << static_cast<int>(Arch));

llvm/trunk/lib/TextAPI/MachO/Architecture.cpp

 
 namespace llvm {
 namespace MachO {
 
 Architecture getArchitectureFromCpuType(uint32_t CPUType, uint32_t CPUSubType) {
 #define ARCHINFO(Arch, Type, Subtype)                                          \
   if (CPUType == (Type) &&                                                     \
       (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) == (Subtype))                    \
-    return Architecture::Arch;
+    return AK_##Arch;
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
 
-  return Architecture::unknown;
+  return AK_unknown;
 }
 
 Architecture getArchitectureFromName(StringRef Name) {
   return StringSwitch<Architecture>(Name)
-#define ARCHINFO(Arch, Type, Subtype) .Case(#Arch, Architecture::Arch)
+#define ARCHINFO(Arch, Type, Subtype) .Case(#Arch, AK_##Arch)
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
-      .Default(Architecture::unknown);
+      .Default(AK_unknown);
 }
 
 StringRef getArchitectureName(Architecture Arch) {
   switch (Arch) {
 #define ARCHINFO(Arch, Type, Subtype)                                          \
-  case Architecture::Arch:                                                     \
+  case AK_##Arch:                                                              \
     return #Arch;
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
-  case Architecture::unknown:
+  case AK_unknown:
     return "unknown";
   }
 
   // Appease some compilers that cannot figure out that this is a fully covered
   // switch statement.
   return "unknown";
 }
 
 std::pair<uint32_t, uint32_t> getCPUTypeFromArchitecture(Architecture Arch) {
   switch (Arch) {
 #define ARCHINFO(Arch, Type, Subtype)                                          \
-  case Architecture::Arch:                                                     \
+  case AK_##Arch:                                                              \
     return std::make_pair(Type, Subtype);
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
-  case Architecture::unknown:
+  case AK_unknown:
     return std::make_pair(0, 0);
   }
 
   // Appease some compilers that cannot figure out that this is a fully covered
   // switch statement.
   return std::make_pair(0, 0);
 }
 
 raw_ostream &operator<<(raw_ostream &OS, Architecture Arch) {
   OS << getArchitectureName(Arch);
   return OS;
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/trunk/lib/TextAPI/MachO/ArchitectureSet.cpp

 #include "llvm/TextAPI/MachO/ArchitectureSet.h"
 
 namespace llvm {
 namespace MachO {
 
 ArchitectureSet::ArchitectureSet(const std::vector<Architecture> &Archs)
     : ArchitectureSet() {
   for (auto Arch : Archs) {
-    if (Arch == Architecture::unknown)
+    if (Arch == AK_unknown)
       continue;
     set(Arch);
   }
 }
 
 size_t ArchitectureSet::count() const {
   // popcnt
   size_t Cnt = 0;
if (size)
       result.append(" ");
   }
   return result;
 }
 
 ArchitectureSet::operator std::vector<Architecture>() const {
   std::vector<Architecture> archs;
   for (auto arch : *this) {
-    if (arch == Architecture::unknown)
+    if (arch == AK_unknown)
       continue;
     archs.emplace_back(arch);
   }
   return archs;
 }
 
 void ArchitectureSet::print(raw_ostream &os) const { os << std::string(*this); }
 
 raw_ostream &operator<<(raw_ostream &os, ArchitectureSet set) {
   set.print(os);
   return os;
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/trunk/lib/TextAPI/MachO/TextStubCommon.cpp

 }
 QuotingType ScalarTraits<PlatformKind>::mustQuote(StringRef) {
   return QuotingType::None;
 }
 
 void ScalarBitSetTraits<ArchitectureSet>::bitset(IO &IO,
                                                  ArchitectureSet &Archs) {
 #define ARCHINFO(arch, type, subtype)                                          \
-  IO.bitSetCase(Archs, #arch, 1U << static_cast<int>(Architecture::arch));
+  IO.bitSetCase(Archs, #arch, 1U << static_cast<int>(AK_##arch));
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
 }
 
 void ScalarTraits<Architecture>::output(const Architecture &Value, void *,
                                         raw_ostream &OS) {
   OS << Value;
 }

llvm/trunk/unittests/TextAPI/TextStubV1Tests.cpp

static const char tbd_v1_file1[] =
       "    thread-local-symbols: [ _tlv3 ]\n"
       "...\n";
 
   auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_file1, "Test.tbd");
   auto Result = TextAPIReader::get(std::move(Buffer));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
-  auto Archs = Architecture::armv7 | Architecture::armv7s |
-               Architecture::armv7k | Architecture::arm64;
+  auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
   EXPECT_EQ(ObjCConstraintType::None, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
static const char tbd_v1_file2[] = "--- !tapi-tbd-v1\n"
                                      "install-name: Test.dylib\n"
                                      "...\n";
 
   auto Buffer = MemoryBuffer::getMemBuffer(tbd_v1_file2, "Test.tbd");
   auto Result = TextAPIReader::get(std::move(Buffer));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V1, File->getFileType());
-  auto Archs = Architecture::armv7 | Architecture::armv7s |
-               Architecture::armv7k | Architecture::arm64;
+  auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(0U, File->getSwiftABIVersion());
   EXPECT_EQ(ObjCConstraintType::None, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
static const char tbd_v1_file3[] =
       "    objc-classes:    [ _Class1 ]\n"
       "    objc-ivars:      [ _Class1._ivar1 ]\n"
       "...\n";
 
   InterfaceFile File;
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V1);
-  File.setArchitectures(Architecture::i386 | Architecture::x86_64);
+  File.setArchitectures(AK_i386 | AK_x86_64);
   File.setPlatform(PlatformKind::macOS);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setSwiftABIVersion(5);
   File.setObjCConstraint(ObjCConstraintType::Retain_Release);
-  File.addAllowableClient("clientA", Architecture::x86_64);
-  File.addReexportedLibrary("/usr/lib/libfoo.dylib", Architecture::x86_64);
-  File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", Architecture::i386);
-  File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", Architecture::i386,
+  File.addAllowableClient("clientA", AK_x86_64);
+  File.addReexportedLibrary("/usr/lib/libfoo.dylib", AK_x86_64);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", AK_i386);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", AK_i386,
                  SymbolFlags::WeakDefined);
-  File.addSymbol(SymbolKind::GlobalSymbol, "_sym3", Architecture::i386,
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym3", AK_i386,
                  SymbolFlags::ThreadLocalValue);
-  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", Architecture::x86_64);
-  File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1",
-                 Architecture::x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", AK_x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1", AK_x86_64);
   File.addSymbol(SymbolKind::ObjectiveCInstanceVariable, "Class1._ivar1",
-                 Architecture::x86_64);
+                 AK_x86_64);
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   auto Result = TextAPIWriter::writeToStream(OS, File);
   EXPECT_FALSE(Result);
   EXPECT_STREQ(tbd_v1_file3, Buffer.c_str());
 }
 

llvm/trunk/unittests/TextAPI/TextStubV2Tests.cpp

static const char tbd_v2_file1[] =
       "    thread-local-symbols: [ _tlv3 ]\n"
       "...\n";
 
   auto Buffer = MemoryBuffer::getMemBuffer(tbd_v2_file1, "Test.tbd");
   auto Result = TextAPIReader::get(std::move(Buffer));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
-  auto Archs = Architecture::armv7 | Architecture::armv7s |
-               Architecture::armv7k | Architecture::arm64;
+  auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(2, 3, 4), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
   EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
   EXPECT_TRUE(File->isTwoLevelNamespace());
static const char tbd_v2_file2[] =
       "    weak-ref-symbols: [ _undefWeak1, _undefWeak2 ]\n"
       "...\n";
 
   auto Buffer = MemoryBuffer::getMemBuffer(tbd_v2_file2, "Test.tbd");
   auto Result = TextAPIReader::get(std::move(Buffer));
   EXPECT_TRUE(!!Result);
   auto File = std::move(Result.get());
   EXPECT_EQ(FileType::TBD_V2, File->getFileType());
-  auto Archs = Architecture::armv7 | Architecture::armv7s |
-               Architecture::armv7k | Architecture::arm64;
+  auto Archs = AK_armv7 | AK_armv7s | AK_armv7k | AK_arm64;
   EXPECT_EQ(Archs, File->getArchitectures());
   EXPECT_EQ(PlatformKind::iOS, File->getPlatform());
   EXPECT_EQ(std::string("Test.dylib"), File->getInstallName());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCurrentVersion());
   EXPECT_EQ(PackedVersion(1, 0, 0), File->getCompatibilityVersion());
   EXPECT_EQ(2U, File->getSwiftABIVersion());
   EXPECT_EQ(ObjCConstraintType::Retain_Release, File->getObjCConstraint());
   EXPECT_FALSE(File->isTwoLevelNamespace());
static const char tbd_v2_file3[] =
       "    objc-classes:    [ _Class1 ]\n"
       "    objc-ivars:      [ _Class1._ivar1 ]\n"
       "...\n";
 
   InterfaceFile File;
   File.setPath("libfoo.dylib");
   File.setInstallName("/usr/lib/libfoo.dylib");
   File.setFileType(FileType::TBD_V2);
-  File.setArchitectures(Architecture::i386 | Architecture::x86_64);
+  File.setArchitectures(AK_i386 | AK_x86_64);
   File.setPlatform(PlatformKind::macOS);
   File.setCurrentVersion(PackedVersion(1, 2, 3));
   File.setTwoLevelNamespace();
   File.setApplicationExtensionSafe();
   File.setSwiftABIVersion(5);
   File.setObjCConstraint(ObjCConstraintType::Retain_Release);
-  File.addAllowableClient("clientA", Architecture::x86_64);
-  File.addReexportedLibrary("/usr/lib/libfoo.dylib", Architecture::x86_64);
-  File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", Architecture::i386);
-  File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", Architecture::i386,
+  File.addAllowableClient("clientA", AK_x86_64);
+  File.addReexportedLibrary("/usr/lib/libfoo.dylib", AK_x86_64);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym1", AK_i386);
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym2", AK_i386,
                  SymbolFlags::WeakDefined);
-  File.addSymbol(SymbolKind::GlobalSymbol, "_sym3", Architecture::i386,
+  File.addSymbol(SymbolKind::GlobalSymbol, "_sym3", AK_i386,
                  SymbolFlags::ThreadLocalValue);
-  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", Architecture::x86_64);
-  File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1",
-                 Architecture::x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCClass, "Class1", AK_x86_64);
+  File.addSymbol(SymbolKind::ObjectiveCClassEHType, "Class1", AK_x86_64);
   File.addSymbol(SymbolKind::ObjectiveCInstanceVariable, "Class1._ivar1",
-                 Architecture::x86_64);
+                 AK_x86_64);
 
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   auto Result = TextAPIWriter::writeToStream(OS, File);
   EXPECT_FALSE(Result);
   EXPECT_STREQ(tbd_v2_file3, Buffer.c_str());
 }
 #endif // _WIN32