[TextAPI] Express MH_SIM_SUPPORT in tbd files.

[cishida]

Summary

This adds a new optional flag sim_support which is the same as
MH_SIM_SUPPORT in the MachO header.

[ributzka]

LGTM

llvm/include/llvm/TextAPI/InterfaceFile.h

public:
   bool isTwoLevelNamespace() const { return IsTwoLevelNamespace; }
 
   /// Specify if the library is application extension safe (or not).
   void setApplicationExtensionSafe(bool V = true) { IsAppExtensionSafe = V; }
 
   /// Check if the library is application extension safe.
   bool isApplicationExtensionSafe() const { return IsAppExtensionSafe; }
 
+  /// Check if the library has simulator support.
+  bool hasSimulatorSupport() const { return HasSimSupport; }
+
+  /// Specify if the library has simulator support.
+  void setSimulatorSupport(bool V = true) { HasSimSupport = V; }
+
   /// Set the Objective-C constraint.
   void setObjCConstraint(ObjCConstraintType Constraint) {
     ObjcConstraint = Constraint;
   }
 
   /// Get the Objective-C constraint.
   ObjCConstraintType getObjCConstraint() const { return ObjcConstraint; }
 
private:
   std::string Path;
   FileType FileKind{FileType::Invalid};
   std::string InstallName;
   PackedVersion CurrentVersion;
   PackedVersion CompatibilityVersion;
   uint8_t SwiftABIVersion{0};
   bool IsTwoLevelNamespace{false};
   bool IsAppExtensionSafe{false};
+  bool HasSimSupport{false};
   ObjCConstraintType ObjcConstraint = ObjCConstraintType::None;
   std::vector<std::pair<Target, std::string>> ParentUmbrellas;
   std::vector<InterfaceFileRef> AllowableClients;
   std::vector<InterfaceFileRef> ReexportedLibraries;
   std::vector<std::shared_ptr<InterfaceFile>> Documents;
   std::vector<std::pair<Target, std::string>> RPaths;
   std::unique_ptr<SymbolSet> SymbolsSet;
   InterfaceFile *Parent = nullptr;

llvm/lib/TextAPI/InterfaceFile.cpp

if ((CurrentVersion != O.CurrentVersion) ||
       (CompatibilityVersion != O.CompatibilityVersion))
     return false;
   if (SwiftABIVersion != O.SwiftABIVersion)
     return false;
   if (IsTwoLevelNamespace != O.IsTwoLevelNamespace)
     return false;
   if (IsAppExtensionSafe != O.IsAppExtensionSafe)
     return false;
+  if (HasSimSupport != O.HasSimSupport)
+    return false;
   if (ParentUmbrellas != O.ParentUmbrellas)
     return false;
   if (AllowableClients != O.AllowableClients)
     return false;
   if (ReexportedLibraries != O.ReexportedLibraries)
     return false;
   if (*SymbolsSet != *O.SymbolsSet)
     return false;

llvm/lib/TextAPI/TextStubCommon.h

 using UUID = std::pair<llvm::MachO::Target, std::string>;
 
 // clang-format off
 enum TBDFlags : unsigned {
   None                         = 0U,
   FlatNamespace                = 1U << 0,
   NotApplicationExtensionSafe  = 1U << 1,
   InstallAPI                   = 1U << 2,
-  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/InstallAPI),
+  SimulatorSupport             = 1U << 3,
+  LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/SimulatorSupport),
 };
 // clang-format on
 
 LLVM_YAML_STRONG_TYPEDEF(llvm::StringRef, FlowStringRef)
 LLVM_YAML_STRONG_TYPEDEF(uint8_t, SwiftVersion)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(UUID)
 LLVM_YAML_IS_FLOW_SEQUENCE_VECTOR(FlowStringRef)
 

llvm/lib/TextAPI/TextStubV5.cpp

Expected<PackedVersion> getPackedVersion(const Object *File, TBDKey Key) {
   }
 
   return PackedVersion(1, 0, 0);
 }
 
 Expected<TBDFlags> getFlags(const Object *File) {
   TBDFlags Flags = TBDFlags::None;
   const Array *Section = File->getArray(Keys[TBDKey::Flags]);
-  if (!Section)
+  if (!Section || Section->empty())
     return Flags;
 
   for (auto &Val : *Section) {
-    // TODO: Just take first for now.
+    // FIXME: Flags currently apply to all target triples.
     const auto *Obj = Val.getAsObject();
     if (!Obj)
       return make_error<JSONStubError>(getParseErrorMsg(TBDKey::Flags));
 
     auto FlagsOrErr =
         collectFromArray(TBDKey::Attributes, Obj, [&Flags](StringRef Flag) {
           TBDFlags TBDFlag =
               StringSwitch<TBDFlags>(Flag)
                   .Case("flat_namespace", TBDFlags::FlatNamespace)
                   .Case("not_app_extension_safe",
                         TBDFlags::NotApplicationExtensionSafe)
+                  .Case("sim_support", TBDFlags::SimulatorSupport)
                   .Default(TBDFlags::None);
           Flags |= TBDFlag;
         });
 
     if (FlagsOrErr)
       return std::move(FlagsOrErr);
 
     return Flags;
Expected<IFPtr> parseToInterfaceFile(const Object *File) {
   IFPtr F(new InterfaceFile);
   F->setInstallName(Name);
   F->setCurrentVersion(CurrVersion);
   F->setCompatibilityVersion(CompVersion);
   F->setSwiftABIVersion(SwiftABI);
   F->setTwoLevelNamespace(!(Flags & TBDFlags::FlatNamespace));
   F->setApplicationExtensionSafe(
       !(Flags & TBDFlags::NotApplicationExtensionSafe));
+  F->setSimulatorSupport((Flags & TBDFlags::SimulatorSupport));
   for (auto &T : Targets)
     F->addTarget(T);
   for (auto &[Lib, Targets] : Clients)
     for (auto Target : Targets)
       F->addAllowableClient(Lib, Target);
   for (auto &[Lib, Targets] : ReexportLibs)
     for (auto Target : Targets)
       F->addReexportedLibrary(Lib, Target);

 
 Array serializeFlags(const InterfaceFile *File) {
   // TODO: Give all Targets the same flags for now.
   Array Flags;
   if (!File->isTwoLevelNamespace())
     Flags.emplace_back("flat_namespace");
   if (!File->isApplicationExtensionSafe())
     Flags.emplace_back("not_app_extension_safe");
+  if (File->hasSimulatorSupport())
+    Flags.emplace_back("sim_support");
   return serializeScalar(TBDKey::Attributes, std::move(Flags));
 }
 
 Expected<Object> serializeIF(const InterfaceFile *File) {
   Object Library;
 
   // Handle required keys.
   TargetList ActiveTargets{File->targets().begin(), File->targets().end()};

llvm/tools/llvm-readtapi/DiffEngine.cpp

if (IFLHS->isApplicationExtensionSafe() !=
       IFRHS->isApplicationExtensionSafe())
     Output.push_back(
         recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                               lhs, IFLHS->isApplicationExtensionSafe()),
                           DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
                               rhs, IFRHS->isApplicationExtensionSafe()),
                           "Application Extension Safe"));
 
+  if (IFLHS->hasSimulatorSupport() != IFRHS->hasSimulatorSupport())
+    Output.push_back(recordDifferences(DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
+                                           lhs, IFLHS->hasSimulatorSupport()),
+                                       DiffScalarVal<bool, AD_Diff_Scalar_Bool>(
+                                           rhs, IFRHS->hasSimulatorSupport()),
+                                       "Simulator Support"));
+
   if (IFLHS->reexportedLibraries() != IFRHS->reexportedLibraries())
     Output.push_back(recordDifferences(IFLHS->reexportedLibraries(),
                                        IFRHS->reexportedLibraries(),
                                        "Reexported Libraries"));
 
   if (IFLHS->allowableClients() != IFRHS->allowableClients())
     Output.push_back(recordDifferences(IFLHS->allowableClients(),
                                        IFRHS->allowableClients(),

llvm/unittests/TextAPI/TextStubV5Tests.cpp

"main_library": {
 
   Expected<TBDFile> Result =
       TextAPIReader::get(MemoryBufferRef(TBDv5File, "Test.tbd"));
   EXPECT_FALSE(!!Result);
   std::string ErrorMessage = toString(Result.takeError());
   EXPECT_EQ("invalid min_deployment section\n", ErrorMessage);
 }
 
+TEST(TBDv5, SimSupport) {
+  static const char TBDv5File[] = R"({ 
+"tapi_tbd_version": 5,
+"main_library": {
+  "target_info": [
+    {
+      "target": "arm64-macos",
+      "min_deployment": "11.1" 
+    }
+  ],
+  "install_names":[
+    { "name":"/S/L/F/Foo.framework/Foo" }
+  ],
+  "flags":[ 
+    { "attributes": ["sim_support"] }
+  ] 
+}})";
+
+  Expected<TBDFile> Result =
+      TextAPIReader::get(MemoryBufferRef(TBDv5File, "Test.tbd"));
+  EXPECT_TRUE(!!Result);
+  Target ExpectedTarget = Target(AK_arm64, PLATFORM_MACOS, VersionTuple(11, 1));
+  TBDFile ReadFile = std::move(Result.get());
+  EXPECT_EQ(FileType::TBD_V5, ReadFile->getFileType());
+  EXPECT_EQ(std::string("/S/L/F/Foo.framework/Foo"),
+            ReadFile->getInstallName());
+  EXPECT_TRUE(ReadFile->targets().begin() != ReadFile->targets().end());
+  EXPECT_EQ(*ReadFile->targets().begin(), ExpectedTarget);
+  EXPECT_TRUE(ReadFile->hasSimulatorSupport());
+}
+
 TEST(TBDv5, MergeIF) {
   static const char TBDv5FileA[] = R"({
 "tapi_tbd_version": 5,
 "main_library": {
   "target_info": [
     {
       "target": "x86_64-macos",
       "min_deployment": "10.14"