[lld-macho][nfc] Avoid using std::map for PlatformKinds

[int3]

Summary

The mappings we were using had a small number of keys, so a vector is
probably better. This allows us to remove the last usage of std::map in
our codebase.

I also used removeSimulator to simplify the code a bit further.

[tschuett]

switch statements are too verbose? In the removeSimulator case, I would expect it to be shorter and more readable. And why is removeSimulatornot somewhere in llvm Binaryformat?

[int3]

In the removeSimulator case, I would expect it to be shorter and more readable.

I prefer to keep to the same code pattern as the other two PlatformKind mappings.

And why is removeSimulator not somewhere in llvm Binaryformat?

That file doesn't seem to have a whole lot of helper functions, just struct definitions.

[thakis]

lld/MachO/Driver.cpp

854

I agree that a switch seems like the obvious fit here, but *shrug*

[int3]

lld/MachO/Driver.cpp

854

okay yeah I forgot that we don't need an extra line for break since we can return early. changing

lld/MachO/Driver.h

 #include "llvm/Support/MemoryBuffer.h"
 
 #include <set>
 #include <type_traits>
 
 namespace llvm {
 namespace MachO {
 class InterfaceFile;
+enum class PlatformKind : unsigned;
 } // namespace MachO
 } // namespace llvm
 
 namespace lld {
 namespace macho {
 
 class DylibFile;
 class InputFile;

 llvm::Optional<InputFile *> loadArchiveMember(MemoryBufferRef, uint32_t modTime,
                                               StringRef archiveName,
                                               bool objCOnly);
 
 uint32_t getModTime(llvm::StringRef path);
 
 void printArchiveMemberLoad(StringRef reason, const InputFile *);
 
+// Map simulator platforms to their underlying device platform.
+llvm::MachO::PlatformKind removeSimulator(llvm::MachO::PlatformKind platform);
+
 // Helper class to export dependency info.
 class DependencyTracker {
 public:
   explicit DependencyTracker(llvm::StringRef path);
 
   // Adds the given path to the set of not-found files.
   inline void logFileNotFound(const Twine &path) {
     if (active)

lld/MachO/Driver.cpp

if (!isPowerOf2_32(align)) {
             "' (in base 16) not a power of two");
       continue;
     }
     sectAligns.push_back({segName, sectName, align});
   }
   return sectAligns;
 }
 
+PlatformKind macho::removeSimulator(PlatformKind platform) {
+  switch (platform) {
+  case PlatformKind::iOSSimulator:
+    return PlatformKind::iOS;
+  case PlatformKind::tvOSSimulator:
+    return PlatformKind::tvOS;
+  case PlatformKind::watchOSSimulator:
+    return PlatformKind::watchOS;
+  default:
+    return platform;
+  }
+}
+
 static bool dataConstDefault(const InputArgList &args) {
-  static const std::map<PlatformKind, VersionTuple> minVersion = {
+  static const std::vector<std::pair<PlatformKind, VersionTuple>> minVersion = {
       {PlatformKind::macOS, VersionTuple(10, 15)},
       {PlatformKind::iOS, VersionTuple(13, 0)},
-      {PlatformKind::iOSSimulator, VersionTuple(13, 0)},
       {PlatformKind::tvOS, VersionTuple(13, 0)},
-      {PlatformKind::tvOSSimulator, VersionTuple(13, 0)},
       {PlatformKind::watchOS, VersionTuple(6, 0)},
-      {PlatformKind::watchOSSimulator, VersionTuple(6, 0)},
       {PlatformKind::bridgeOS, VersionTuple(4, 0)}};
-  auto it = minVersion.find(config->platformInfo.target.Platform);
+  PlatformKind platform = removeSimulator(config->platformInfo.target.Platform);
+  auto it = llvm::find_if(minVersion,
+                          [&](const auto &p) { return p.first == platform; });
   if (it != minVersion.end())
     if (config->platformInfo.minimum < it->second)
       return false;
 
   switch (config->outputType) {
   case MH_EXECUTE:
     return !args.hasArg(OPT_no_pie);
   case MH_BUNDLE:

lld/MachO/InputFiles.h

 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/TextAPI/TextAPIReader.h"
 
-#include <map>
 #include <vector>
 
 namespace llvm {
 namespace lto {
 class InputFile;
 } // namespace lto
 namespace MachO {
 class InterfaceFile;

lld/MachO/InputFiles.cpp

for (auto *cmd : findCommands<version_min_command>(
     }
     info.minimum = decodeVersion(cmd->version);
     platformInfos.emplace_back(std::move(info));
   }
 
   return platformInfos;
 }
 
-static PlatformKind removeSimulator(PlatformKind platform) {
-  // Mapping of platform to simulator and vice-versa.
-  static const std::map<PlatformKind, PlatformKind> platformMap = {
-      {PlatformKind::iOSSimulator, PlatformKind::iOS},
-      {PlatformKind::tvOSSimulator, PlatformKind::tvOS},
-      {PlatformKind::watchOSSimulator, PlatformKind::watchOS}};
-
-  auto iter = platformMap.find(platform);
-  if (iter == platformMap.end())
-    return platform;
-  return iter->second;
-}
-
 static bool checkCompatibility(const InputFile *input) {
   std::vector<PlatformInfo> platformInfos = getPlatformInfos(input);
   if (platformInfos.empty())
     return true;
 
   auto it = find_if(platformInfos, [&](const PlatformInfo &info) {
     return removeSimulator(info.target.Platform) ==
            removeSimulator(config->platform());

lld/MachO/Writer.cpp

if (const auto *defined = dyn_cast<Defined>(sym)) {
       dysym->getFile()->refState =
           std::max(dysym->getFile()->refState, dysym->getRefState());
     }
   }
 }
 
 // TODO: ld64 enforces the old load commands in a few other cases.
 static bool useLCBuildVersion(const PlatformInfo &platformInfo) {
-  static const std::map<PlatformKind, llvm::VersionTuple> minVersion = {
-      {PlatformKind::macOS, llvm::VersionTuple(10, 14)},
+  static const std::vector<std::pair<PlatformKind, llvm::VersionTuple>>
+      minVersion = {{PlatformKind::macOS, llvm::VersionTuple(10, 14)},
                     {PlatformKind::iOS, llvm::VersionTuple(12, 0)},
                     {PlatformKind::iOSSimulator, llvm::VersionTuple(13, 0)},
                     {PlatformKind::tvOS, llvm::VersionTuple(12, 0)},
                     {PlatformKind::tvOSSimulator, llvm::VersionTuple(13, 0)},
                     {PlatformKind::watchOS, llvm::VersionTuple(5, 0)},
                     {PlatformKind::watchOSSimulator, llvm::VersionTuple(6, 0)}};
-  auto it = minVersion.find(platformInfo.target.Platform);
+  auto it = llvm::find_if(minVersion, [&](const auto &p) {
+    return p.first == platformInfo.target.Platform;
+  });
   return it == minVersion.end() ? true : platformInfo.minimum >= it->second;
 }
 
 template <class LP> void Writer::createLoadCommands() {
   uint8_t segIndex = 0;
   for (OutputSegment *seg : outputSegments) {
     in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg));
     seg->index = segIndex++;