text: //===- llvm/TextAPI/InterfaceFile.h - TAPI Interface File -------*- C++ -*-===//
  //
  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  // See https://llvm.org/LICENSE.txt for license information.
  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  //
  //===----------------------------------------------------------------------===//
  //
  // A generic and abstract interface representation for linkable objects. This
  // could be an MachO executable, bundle, dylib, or text-based stub file.
  //
  //===----------------------------------------------------------------------===//
  
  #ifndef LLVM_TEXTAPI_MACHO_INTERFACEFILE_H
  #define LLVM_TEXTAPI_MACHO_INTERFACEFILE_H
  
  #include "llvm/ADT/BitmaskEnum.h"
  #include "llvm/ADT/DenseMap.h"
  #include "llvm/ADT/Hashing.h"
  #include "llvm/ADT/StringRef.h"
  #include "llvm/ADT/iterator.h"
  #include "llvm/BinaryFormat/MachO.h"
  #include "llvm/BinaryFormat/Magic.h"
  #include "llvm/Support/Allocator.h"
  #include "llvm/Support/Error.h"
  #include "llvm/TextAPI/Architecture.h"
  #include "llvm/TextAPI/ArchitectureSet.h"
  #include "llvm/TextAPI/PackedVersion.h"
  #include "llvm/TextAPI/Platform.h"
  #include "llvm/TextAPI/Symbol.h"
  #include "llvm/TextAPI/Target.h"
  
  namespace llvm {
  namespace MachO {
  
  /// Defines a list of Objective-C constraints.
  enum class ObjCConstraintType : unsigned {
    /// No constraint.
    None = 0,
  
    /// Retain/Release.
    Retain_Release = 1,
  
    /// Retain/Release for Simulator.
    Retain_Release_For_Simulator = 2,
  
    /// Retain/Release or Garbage Collection.
    Retain_Release_Or_GC = 3,
  
    /// Garbage Collection.
    GC = 4,
  };
  
  // clang-format off
  
  /// Defines the file type this file represents.
  enum FileType : unsigned {
    /// Invalid file type.
    Invalid = 0U,
  
    /// Text-based stub file (.tbd) version 1.0
    TBD_V1  = 1U <<  0,
  
    /// Text-based stub file (.tbd) version 2.0
    TBD_V2  = 1U <<  1,
  
    /// Text-based stub file (.tbd) version 3.0
    TBD_V3  = 1U <<  2,
  
    /// Text-based stub file (.tbd) version 4.0
    TBD_V4  = 1U <<  3,
  
    All     = ~0U,
  
    LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/All),
  };
  
  // clang-format on
  
  /// Reference to an interface file.
  class InterfaceFileRef {
  public:
    InterfaceFileRef() = default;
  
    InterfaceFileRef(StringRef InstallName) : InstallName(InstallName) {}
  
    InterfaceFileRef(StringRef InstallName, const TargetList Targets)
        : InstallName(InstallName), Targets(std::move(Targets)) {}
  
    StringRef getInstallName() const { return InstallName; };
  
    void addTarget(const Target &Target);
    template <typename RangeT> void addTargets(RangeT &&Targets) {
      for (const auto &Target : Targets)
        addTarget(Target(Target));
    }
  
    using const_target_iterator = TargetList::const_iterator;
    using const_target_range = llvm::iterator_range<const_target_iterator>;
    const_target_range targets() const { return {Targets}; }
  
    ArchitectureSet getArchitectures() const {
      return mapToArchitectureSet(Targets);
    }
  
    PlatformSet getPlatforms() const { return mapToPlatformSet(Targets); }
  
    bool operator==(const InterfaceFileRef &O) const {
      return std::tie(InstallName, Targets) == std::tie(O.InstallName, O.Targets);
    }
  
    bool operator!=(const InterfaceFileRef &O) const {
      return std::tie(InstallName, Targets) != std::tie(O.InstallName, O.Targets);
    }
  
    bool operator<(const InterfaceFileRef &O) const {
      return std::tie(InstallName, Targets) < std::tie(O.InstallName, O.Targets);
    }
  
  private:
    std::string InstallName;
    TargetList Targets;
  };
  
  } // end namespace MachO.
  
  struct SymbolsMapKey {
    MachO::SymbolKind Kind;
    StringRef Name;
  
    SymbolsMapKey(MachO::SymbolKind Kind, StringRef Name)
        : Kind(Kind), Name(Name) {}
  };
  template <> struct DenseMapInfo<SymbolsMapKey> {
    static inline SymbolsMapKey getEmptyKey() {
      return SymbolsMapKey(MachO::SymbolKind::GlobalSymbol, StringRef{});
    }
  
    static inline SymbolsMapKey getTombstoneKey() {
      return SymbolsMapKey(MachO::SymbolKind::ObjectiveCInstanceVariable,
                           StringRef{});
    }
  
    static unsigned getHashValue(const SymbolsMapKey &Key) {
      return hash_combine(hash_value(Key.Kind), hash_value(Key.Name));
    }
  
    static bool isEqual(const SymbolsMapKey &LHS, const SymbolsMapKey &RHS) {
      return std::tie(LHS.Kind, LHS.Name) == std::tie(RHS.Kind, RHS.Name);
    }
  };
  
  namespace MachO {
  
  /// Defines the interface file.
  class InterfaceFile {
  public:
    /// Set the path from which this file was generated (if applicable).
    ///
    /// \param Path_ The path to the source file.
    void setPath(StringRef Path_) { Path = std::string(Path_); }
  
    /// Get the path from which this file was generated (if applicable).
    ///
    /// \return The path to the source file or empty.
    StringRef getPath() const { return Path; }
  
    /// Set the file type.
    ///
    /// This is used by the YAML writer to identify the specification it should
    /// use for writing the file.
    ///
    /// \param Kind The file type.
    void setFileType(FileType Kind) { FileKind = Kind; }
  
    /// Get the file type.
    ///
    /// \return The file type.
    FileType getFileType() const { return FileKind; }
  
    /// Get the architectures.
    ///
    /// \return The applicable architectures.
    ArchitectureSet getArchitectures() const {
      return mapToArchitectureSet(Targets);
    }
  
    /// Get the platforms.
    ///
    /// \return The applicable platforms.
    PlatformSet getPlatforms() const { return mapToPlatformSet(Targets); }
  
    /// Set and add target.
    ///
    /// \param Target the target to add into.
    void addTarget(const Target &Target);
  
    /// Set and add targets.
    ///
    /// Add the subset of llvm::triples that is supported by Tapi
    ///
    /// \param Targets the collection of targets.
    template <typename RangeT> void addTargets(RangeT &&Targets) {
      for (const auto &Target_ : Targets)
        addTarget(Target(Target_));
    }
  
    using const_target_iterator = TargetList::const_iterator;
    using const_target_range = llvm::iterator_range<const_target_iterator>;
    const_target_range targets() const { return {Targets}; }
  
    using const_filtered_target_iterator =
        llvm::filter_iterator<const_target_iterator,
                              std::function<bool(const Target &)>>;
    using const_filtered_target_range =
        llvm::iterator_range<const_filtered_target_iterator>;
    const_filtered_target_range targets(ArchitectureSet Archs) const;
  
    /// Set the install name of the library.
    void setInstallName(StringRef InstallName_) {
      InstallName = std::string(InstallName_);
    }
  
    /// Get the install name of the library.
    StringRef getInstallName() const { return InstallName; }
  
    /// Set the current version of the library.
    void setCurrentVersion(PackedVersion Version) { CurrentVersion = Version; }
  
    /// Get the current version of the library.
    PackedVersion getCurrentVersion() const { return CurrentVersion; }
  
    /// Set the compatibility version of the library.
    void setCompatibilityVersion(PackedVersion Version) {
      CompatibilityVersion = Version;
    }
  
    /// Get the compatibility version of the library.
    PackedVersion getCompatibilityVersion() const { return CompatibilityVersion; }
  
    /// Set the Swift ABI version of the library.
    void setSwiftABIVersion(uint8_t Version) { SwiftABIVersion = Version; }
  
    /// Get the Swift ABI version of the library.
    uint8_t getSwiftABIVersion() const { return SwiftABIVersion; }
  
    /// Specify if the library uses two-level namespace (or flat namespace).
    void setTwoLevelNamespace(bool V = true) { IsTwoLevelNamespace = V; }
  
    /// Check if the library uses two-level namespace.
    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; }
  
    /// Set the Objective-C constraint.
    void setObjCConstraint(ObjCConstraintType Constraint) {
      ObjcConstraint = Constraint;
    }
  
    /// Get the Objective-C constraint.
    ObjCConstraintType getObjCConstraint() const { return ObjcConstraint; }
  
    /// Specify if this file was generated during InstallAPI (or not).
    void setInstallAPI(bool V = true) { IsInstallAPI = V; }
  
    /// Check if this file was generated during InstallAPI.
    bool isInstallAPI() const { return IsInstallAPI; }
  
    /// Set the parent umbrella frameworks.
    /// \param Target_ The target applicable to Parent
    /// \param Parent  The name of Parent
    void addParentUmbrella(const Target &Target_, StringRef Parent);
  
    /// Get the list of Parent Umbrella frameworks.
    ///
    /// \return Returns a list of target information and install name of parent
    /// umbrellas.
    const std::vector<std::pair<Target, std::string>> &umbrellas() const {
      return ParentUmbrellas;
    }
  
    /// Add an allowable client.
    ///
    /// Mach-O Dynamic libraries have the concept of allowable clients that are
    /// checked during static link time. The name of the application or library
    /// that is being generated needs to match one of the allowable clients or the
    /// linker refuses to link this library.
    ///
    /// \param InstallName The name of the client that is allowed to link this
    /// library.
    /// \param Target The target triple for which this applies.
    void addAllowableClient(StringRef InstallName, const Target &Target);
  
    /// Get the list of allowable clients.
    ///
    /// \return Returns a list of allowable clients.
    const std::vector<InterfaceFileRef> &allowableClients() const {
      return AllowableClients;
    }
  
    /// Add a re-exported library.
    ///
    /// \param InstallName The name of the library to re-export.
    /// \param Target The target triple for which this applies.
    void addReexportedLibrary(StringRef InstallName, const Target &Target);
  
    /// Get the list of re-exported libraries.
    ///
    /// \return Returns a list of re-exported libraries.
    const std::vector<InterfaceFileRef> &reexportedLibraries() const {
      return ReexportedLibraries;
    }
  
    /// Add an Target/UUID pair.
    ///
    /// \param Target The target triple for which this applies.
    /// \param UUID The UUID of the library for the specified architecture.
    void addUUID(const Target &Target, StringRef UUID);
  
    /// Add an Target/UUID pair.
    ///
    /// \param Target The target triple for which this applies.
    /// \param UUID The UUID of the library for the specified architecture.
    void addUUID(const Target &Target, uint8_t UUID[16]);
  
    /// Get the list of Target/UUID pairs.
    ///
    /// \return Returns a list of Target/UUID pairs.
    const std::vector<std::pair<Target, std::string>> &uuids() const {
      return UUIDs;
    }
  
    /// Add a library for inlining to top level library.
    ///
    ///\param Document The library to inline with top level library.
    void addDocument(std::shared_ptr<InterfaceFile> &&Document);
  
    /// Returns the pointer to parent document if exists or nullptr otherwise.
    InterfaceFile *getParent() const { return Parent; }
  
    /// Get the list of inlined libraries.
    ///
    /// \return Returns a list of the inlined frameworks.
    const std::vector<std::shared_ptr<InterfaceFile>> &documents() const {
      return Documents;
    }
  
    /// Add a symbol to the symbols list or extend an existing one.
    void addSymbol(SymbolKind Kind, StringRef Name, const TargetList &Targets,
                   SymbolFlags Flags = SymbolFlags::None);
  
    using SymbolMapType = DenseMap<SymbolsMapKey, Symbol *>;
    struct const_symbol_iterator
        : public iterator_adaptor_base<
              const_symbol_iterator, SymbolMapType::const_iterator,
              std::forward_iterator_tag, const Symbol *, ptrdiff_t,
              const Symbol *, const Symbol *> {
      const_symbol_iterator() = default;
  
      template <typename U>
      const_symbol_iterator(U &&u)
          : iterator_adaptor_base(std::forward<U &&>(u)) {}
  
      reference operator*() const { return I->second; }
      pointer operator->() const { return I->second; }
    };
  
    using const_symbol_range = iterator_range<const_symbol_iterator>;
  
    using const_filtered_symbol_iterator =
        filter_iterator<const_symbol_iterator,
                        std::function<bool(const Symbol *)>>;
    using const_filtered_symbol_range =
        iterator_range<const_filtered_symbol_iterator>;
  
    const_symbol_range symbols() const {
      return {Symbols.begin(), Symbols.end()};
    }
  
    const_filtered_symbol_range exports() const {
      std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
        return !Symbol->isUndefined();
      };
      return make_filter_range(
          make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
          fn);
    }
  
    const_filtered_symbol_range undefineds() const {
      std::function<bool(const Symbol *)> fn = [](const Symbol *Symbol) {
        return Symbol->isUndefined();
      };
      return make_filter_range(
          make_range<const_symbol_iterator>({Symbols.begin()}, {Symbols.end()}),
          fn);
    }
  
    /// The equality is determined by attributes that impact linking
    /// compatibilities. UUIDs, Path, & FileKind are irrelevant since these by
    /// itself should not impact linking.
    /// This is an expensive operation.
    bool operator==(const InterfaceFile &O) const;
  
    bool operator!=(const InterfaceFile &O) const { return !(*this == O); }
  
  private:
    llvm::BumpPtrAllocator Allocator;
    StringRef copyString(StringRef String) {
      if (String.empty())
        return {};
  
      void *Ptr = Allocator.Allocate(String.size(), 1);
      memcpy(Ptr, String.data(), String.size());
      return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
    }
  
    TargetList Targets;
    std::string Path;
    FileType FileKind;
    std::string InstallName;
    PackedVersion CurrentVersion;
    PackedVersion CompatibilityVersion;
    uint8_t SwiftABIVersion{0};
    bool IsTwoLevelNamespace{false};
    bool IsAppExtensionSafe{false};
    bool IsInstallAPI{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>> UUIDs;
    SymbolMapType Symbols;
    InterfaceFile *Parent = nullptr;
  };
  
  template <typename DerivedT, typename KeyInfoT, typename BucketT>
  bool operator==(const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
                                     KeyInfoT, BucketT> &LHS,
                  const DenseMapBase<DerivedT, SymbolsMapKey, MachO::Symbol *,
                                     KeyInfoT, BucketT> &RHS) {
    if (LHS.size() != RHS.size())
      return false;
    for (auto KV : LHS) {
      auto I = RHS.find(KV.first);
      if (I == RHS.end() || *I->second != *KV.second)
        return false;
    }
    return true;
  }
  
  } // end namespace MachO.
  } // end namespace llvm.
  
  #endif // LLVM_TEXTAPI_MACHO_INTERFACEFILE_H
  