[llvm][llvm-nm] add TextAPI/MachO support

[cishida]

Summary

This completes the needed glueing to support reading tbd files from nm.
This includes specifying which slice filtering with --arch and a new
option specifically for tbd files --add-inlinedinfo which will show
the reexported libraries that are appended in the tbd file.

[JDevlieghere]

llvm/include/llvm/Object/TapiFile.h

57

Why not just Arch like the ctor argument?

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

50

Would getNumberOfBits be a more "generic" API?

llvm/lib/Object/TapiFile.cpp

44

Why not do this in the initializer list?

llvm/lib/TextAPI/MachO/Architecture.cpp

91

llvm_unreachable("Fully covered switch above!");

llvm/tools/llvm-nm/llvm-nm.cpp

2111

I think you should be able to do:

if (auto ObjOrErr = I.getAsObjectFile())

[cishida]

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

50

I agree but I named that to conform to the MachO api.

[JDevlieghere]

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

50

Fair enough.

[cishida]

Updating to address comments, add more const correctness, fix casing on FileCheck

[jhenderson]

I don't know anything about the tapi/tbd stuff, to speak of, so I can't give any concrete comments, just a number of nits.

llvm/include/llvm/Object/TapiUniversal.h

57

Nit: missing blank line between this and the previous function.

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

49

Nit: missing full stop.

llvm/lib/Object/TapiUniversal.cpp

33–43

I see auto was being used before in various places, but I'm not a fan where it's not clear what the type is (which is the case in almost every instance in these two blocks). However, I'm not familiar with this area of the code base (i.e. the tapi stuff), so feel free to ignore me if this is common style in this area.

llvm/tools/llvm-nm/llvm-nm.cpp

2101

Same comment as earlier - don't use auto where the type is not obvious from the immediate context.

2105

Example why auto is bad: I'm assuming Name is actually a StringRef, in which case, you don't need the const & part of this, since StringRef is designed for lightweight copying.

[cishida]

adopintg jhenderson's comments to increase Readablity & Coding Guidelines

[JDevlieghere]

LGTM

[MaskRay]

llvm/tools/llvm-nm/llvm-nm.cpp

2111

Obj is only used once. Inline the variable to the call site

2116

auto -> Error

[MaskRay]

llvm/test/Object/Inputs/tapi-invalid-v2.tbd

1

Consider moving new test/Object/* tests to test/Object/MachO/*

[cishida]

the landed patch has applied MaskRay's comments.

llvm/test/Object/Inputs/tapi-invalid-v2.tbd

1

Since that directory doesn't exist in the repo currently, I will land a separate NFC commit to move all the machO based nm tests there.

llvm/docs/CommandGuide/llvm-nm.rst

 MACH-O SPECIFIC OPTIONS
 -----------------------
 
 .. option:: --add-dyldinfo
 
  Add symbols from the dyldinfo, if they are not already in the symbol table.
  This is the default.
 
+.. option:: --add-inlinedinfo
+
+ Add symbols from the inlined libraries, TBD file inputs only.
+
 .. option:: --arch=<arch1[,arch2,...]>
 
  Dump the symbols from the specified architecture(s).
 
 .. option:: --dyldinfo-only
 
  Dump only symbols from the dyldinfo.
 

llvm/include/llvm/Object/TapiFile.h

public:
   Expected<uint32_t> getSymbolFlags(DataRefImpl DRI) const override;
 
   basic_symbol_iterator symbol_begin() const override;
 
   basic_symbol_iterator symbol_end() const override;
 
   static bool classof(const Binary *v) { return v->isTapiFile(); }
 
+  bool is64Bit() { return MachO::is64Bit(Arch); }
+
 private:
   struct Symbol {
     StringRef Prefix;
     StringRef Name;
     uint32_t Flags;
 
     constexpr Symbol(StringRef Prefix, StringRef Name, uint32_t Flags)
         : Prefix(Prefix), Name(Name), Flags(Flags) {}
   };
 
   std::vector<Symbol> Symbols;
+  MachO::Architecture Arch;
 };
 
 } // end namespace object.
 } // end namespace llvm.
 
 #endif // LLVM_OBJECT_TAPI_FILE_H

llvm/include/llvm/Object/TapiUniversal.h

public:
     ObjectForArch getNext() const { return ObjectForArch(Parent, Index + 1); }
 
     bool operator==(const ObjectForArch &Other) const {
       return (Parent == Other.Parent) && (Index == Other.Index);
     }
 
     uint32_t getCPUType() const {
       auto Result =
-          MachO::getCPUTypeFromArchitecture(Parent->Architectures[Index]);
+          MachO::getCPUTypeFromArchitecture(Parent->Libraries[Index].Arch);
       return Result.first;
     }
 
     uint32_t getCPUSubType() const {
       auto Result =
-          MachO::getCPUTypeFromArchitecture(Parent->Architectures[Index]);
+          MachO::getCPUTypeFromArchitecture(Parent->Libraries[Index].Arch);
       return Result.second;
     }
 
     StringRef getArchFlagName() const {
-      return MachO::getArchitectureName(Parent->Architectures[Index]);
+      return MachO::getArchitectureName(Parent->Libraries[Index].Arch);
+    }
+
+    std::string getInstallName() const {
+      return Parent->Libraries[Index].InstallName.str();
+    }
+
+    bool isTopLevelLib() const {
+      return Parent->ParsedFile->getInstallName() == getInstallName();
     }
 
     Expected<std::unique_ptr<TapiFile>> getAsObjectFile() const;
   };
 
   class object_iterator {
     ObjectForArch Obj;
 
public:
 
   TapiUniversal(MemoryBufferRef Source, Error &Err);
   static Expected<std::unique_ptr<TapiUniversal>>
   create(MemoryBufferRef Source);
   ~TapiUniversal() override;
 
   object_iterator begin_objects() const { return ObjectForArch(this, 0); }
   object_iterator end_objects() const {
-    return ObjectForArch(this, Architectures.size());
+    return ObjectForArch(this, Libraries.size());
   }
 
   iterator_range<object_iterator> objects() const {
     return make_range(begin_objects(), end_objects());
   }
 
-  uint32_t getNumberOfObjects() const { return Architectures.size(); }
+  uint32_t getNumberOfObjects() const { return Libraries.size(); }
 
-  // Cast methods.
   static bool classof(const Binary *v) { return v->isTapiUniversal(); }
 
 private:
+  struct Library {
+    StringRef InstallName;
+    MachO::Architecture Arch;
+  };
+
   std::unique_ptr<MachO::InterfaceFile> ParsedFile;
-  std::vector<MachO::Architecture> Architectures;
+  std::vector<Library> Libraries;
 };
 
 } // end namespace object.
 } // end namespace llvm.
 
 #endif // LLVM_OBJECT_TAPI_UNIVERSAL_H

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

 class raw_ostream;
 class StringRef;
 class Triple;
 
 namespace MachO {
 
 /// Defines the architecture slices that are supported by Text-based Stub files.
 enum Architecture : uint8_t {
-#define ARCHINFO(Arch, Type, SubType) AK_##Arch,
+#define ARCHINFO(Arch, Type, SubType, NumBits) AK_##Arch,
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
   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);
 
 /// Convert an architecture slice to a string.
 StringRef getArchitectureName(Architecture Arch);
 
 /// Convert an architecture slice to a CPU Type and Subtype pair.
 std::pair<uint32_t, uint32_t> getCPUTypeFromArchitecture(Architecture Arch);
 
 /// Convert a target to an architecture slice.
 Architecture mapToArchitecture(const llvm::Triple &Target);
 
+/// Check if architecture is 64 bit.
+bool is64Bit(Architecture);
+
 raw_ostream &operator<<(raw_ostream &OS, Architecture Arch);
 
 } // end namespace MachO.
 } // end namespace llvm.
 
 #endif // LLVM_TEXTAPI_MACHO_ARCHITECTURE_H

llvm/include/llvm/TextAPI/MachO/Architecture.def

 //===- llvm/TextAPI/MachO/Architecture.def - Architecture -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef ARCHINFO
 #define ARCHINFO(arch)
 #endif
 
 ///
 /// X86 architectures sorted by cpu type and sub type id.
 ///
-ARCHINFO(i386, MachO::CPU_TYPE_I386, MachO::CPU_SUBTYPE_I386_ALL)
-ARCHINFO(x86_64, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_ALL)
-ARCHINFO(x86_64h, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_H)
+ARCHINFO(i386, MachO::CPU_TYPE_I386, MachO::CPU_SUBTYPE_I386_ALL, 32)
+ARCHINFO(x86_64, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_ALL, 64)
+ARCHINFO(x86_64h, MachO::CPU_TYPE_X86_64, MachO::CPU_SUBTYPE_X86_64_H, 64)
 
 
 ///
 /// ARM architectures sorted by cpu sub type id.
 ///
-ARCHINFO(armv4t, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V4T)
-ARCHINFO(armv6, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6)
-ARCHINFO(armv5, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V5TEJ)
-ARCHINFO(armv7, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7)
-ARCHINFO(armv7s, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7S)
-ARCHINFO(armv7k, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7K)
-ARCHINFO(armv6m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6M)
-ARCHINFO(armv7m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7M)
-ARCHINFO(armv7em, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7EM)
+ARCHINFO(armv4t, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V4T, 32)
+ARCHINFO(armv6, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6, 32)
+ARCHINFO(armv5, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V5TEJ, 32)
+ARCHINFO(armv7, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7, 32)
+ARCHINFO(armv7s, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7S, 32)
+ARCHINFO(armv7k, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7K, 32)
+ARCHINFO(armv6m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V6M, 32)
+ARCHINFO(armv7m, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7M, 32)
+ARCHINFO(armv7em, MachO::CPU_TYPE_ARM, MachO::CPU_SUBTYPE_ARM_V7EM, 32)
 
 
 ///
 /// ARM64 architectures sorted by cpu sub type id.
 ///
-ARCHINFO(arm64, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64_ALL)
-ARCHINFO(arm64e, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64E)
+ARCHINFO(arm64, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64_ALL, 64)
+ARCHINFO(arm64e, MachO::CPU_TYPE_ARM64, MachO::CPU_SUBTYPE_ARM64E, 64)

llvm/lib/Object/TapiFile.cpp

static uint32_t getFlags(const Symbol *Sym) {
   if (Sym->isWeakDefined() || Sym->isWeakReferenced())
     Flags |= BasicSymbolRef::SF_Weak;
 
   return Flags;
 }
 
 TapiFile::TapiFile(MemoryBufferRef Source, const InterfaceFile &interface,
                    Architecture Arch)
-    : SymbolicFile(ID_TapiFile, Source) {
+    : SymbolicFile(ID_TapiFile, Source), Arch(Arch) {
   for (const auto *Symbol : interface.symbols()) {
     if (!Symbol->getArchitectures().has(Arch))
       continue;
 
     switch (Symbol->getKind()) {
     case SymbolKind::GlobalSymbol:
       Symbols.emplace_back(StringRef(), Symbol->getName(), getFlags(Symbol));
       break;
     case SymbolKind::ObjectiveCClass:

llvm/lib/Object/TapiUniversal.cpp

 #include "llvm/TextAPI/MachO/TextAPIReader.h"
 
 using namespace llvm;
 using namespace MachO;
 using namespace object;
 
 TapiUniversal::TapiUniversal(MemoryBufferRef Source, Error &Err)
     : Binary(ID_TapiUniversal, Source) {
-  auto Result = TextAPIReader::get(Source);
+  Expected<std::unique_ptr<InterfaceFile>> Result = TextAPIReader::get(Source);
   ErrorAsOutParameter ErrAsOuParam(&Err);
   if (!Result) {
     Err = Result.takeError();
     return;
   }
   ParsedFile = std::move(Result.get());
 
-  auto Archs = ParsedFile->getArchitectures();
-  for (auto Arch : Archs)
-    Architectures.emplace_back(Arch);
+  auto FlattenObjectInfo = [this](const auto &File) {
+    StringRef Name = File->getInstallName();
+    for (const Architecture Arch : File->getArchitectures())
+      Libraries.emplace_back(Library({Name, Arch}));
+  };
+
+  FlattenObjectInfo(ParsedFile);
+  // Get inlined documents from tapi file.
+  for (const std::shared_ptr<InterfaceFile> &File : ParsedFile->documents())
+    FlattenObjectInfo(File);
 }
 
 TapiUniversal::~TapiUniversal() = default;
 
 Expected<std::unique_ptr<TapiFile>>
 TapiUniversal::ObjectForArch::getAsObjectFile() const {
   return std::unique_ptr<TapiFile>(new TapiFile(Parent->getMemoryBufferRef(),
                                                 *Parent->ParsedFile.get(),
-                                                Parent->Architectures[Index]));
+                                                Parent->Libraries[Index].Arch));
 }
 
 Expected<std::unique_ptr<TapiUniversal>>
 TapiUniversal::create(MemoryBufferRef Source) {
   Error Err = Error::success();
   std::unique_ptr<TapiUniversal> Ret(new TapiUniversal(Source, Err));
   if (Err)
     return std::move(Err);
   return std::move(Ret);
 }

llvm/lib/TextAPI/MachO/Architecture.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/TextAPI/MachO/Architecture.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/TextAPI/MachO/ArchitectureSet.h"
 
 namespace llvm {
 namespace MachO {
 
 Architecture getArchitectureFromCpuType(uint32_t CPUType, uint32_t CPUSubType) {
-#define ARCHINFO(Arch, Type, Subtype)                                          \
+#define ARCHINFO(Arch, Type, Subtype, NumBits)                                 \
   if (CPUType == (Type) &&                                                     \
       (CPUSubType & ~MachO::CPU_SUBTYPE_MASK) == (Subtype))                    \
     return AK_##Arch;
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
 
   return AK_unknown;
 }
 
 Architecture getArchitectureFromName(StringRef Name) {
   return StringSwitch<Architecture>(Name)
-#define ARCHINFO(Arch, Type, Subtype) .Case(#Arch, AK_##Arch)
+#define ARCHINFO(Arch, Type, Subtype, NumBits) .Case(#Arch, AK_##Arch)
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
       .Default(AK_unknown);
 }
 
 StringRef getArchitectureName(Architecture Arch) {
   switch (Arch) {
-#define ARCHINFO(Arch, Type, Subtype)                                          \
+#define ARCHINFO(Arch, Type, Subtype, NumBits)                                 \
   case AK_##Arch:                                                              \
     return #Arch;
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
   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)                                          \
+#define ARCHINFO(Arch, Type, Subtype, NumBits)                                 \
   case AK_##Arch:                                                              \
     return std::make_pair(Type, Subtype);
 #include "llvm/TextAPI/MachO/Architecture.def"
 #undef ARCHINFO
   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);
 }
 
 Architecture mapToArchitecture(const Triple &Target) {
   return getArchitectureFromName(Target.getArchName());
 }
 
+bool is64Bit(Architecture Arch) {
+  switch (Arch) {
+#define ARCHINFO(Arch, Type, Subtype, NumBits)                                 \
+  case AK_##Arch:                                                              \
+    return NumBits == 64;
+#include "llvm/TextAPI/MachO/Architecture.def"
+#undef ARCHINFO
+  case AK_unknown:
+    return false;
+  }
+
+  llvm_unreachable("Fully handled switch case above.");
+}
+
 raw_ostream &operator<<(raw_ostream &OS, Architecture Arch) {
   OS << getArchitectureName(Arch);
   return OS;
 }
 
 } // end namespace MachO.
 } // end namespace llvm.

llvm/lib/TextAPI/MachO/TextStubCommon.cpp

 }
 
 QuotingType ScalarTraits<PlatformSet>::mustQuote(StringRef) {
   return QuotingType::None;
 }
 
 void ScalarBitSetTraits<ArchitectureSet>::bitset(IO &IO,
                                                  ArchitectureSet &Archs) {
-#define ARCHINFO(arch, type, subtype)                                          \
+#define ARCHINFO(arch, type, subtype, numbits)                                 \
   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/test/Object/Inputs/tapi-invalid-v1.tbd

+--- !tapi-tbd-v1
+
+archs: [ armv7, armv7s, arm64 ]
+
+platform: ios
+install-name: /u/l/libfoo.dylib
+current-version: 1.2.3
+compatibility-version: 1.0
+swift-version: 0
+objc-constraint: none
+expors:
+ - archs: [ arm64, armv7 ]
+   allowed-clients: [ client ]
+   symbols: [ _sym, _test, _a, _b, ]
+...

llvm/test/Object/Inputs/tapi-invalid-v2.tbd

+--- !tapi-tbd-v2
+uuids: [ "armv7: 00000000-0000-0000-0000-000000000000",
+         "armv7s: 11111111-1111-1111-1111-111111111111",
+         "arm64: 22222222-2222-2222-2222-222222222222" ]
+platform: ios
+flags: [ installapi ]
+install-name: /u/l/libfoo.dylib
+current-version: 1.2.3
+compatibility-version: 1.0
+swift-version: 0
+objc-constraint: retain_release
+parent-umbrella: Umbrella.dylib
+exports:
+  - archs: [ armv7, armv7s, arm64 ]
+    allowable-clients: [ client ]
+    re-exports: [ ]
+    symbols: [ _sym1, _sym2, _sym3 ]
+undefineds:
+  - archs: [ arm64 ]
+    symbols: [ _sym ]
+...

llvm/test/Object/Inputs/tapi-invalid-v3.tbd

+--- !tapi-tbd-v3
+archs: [ i386, armv7, armv7s ]
+platform: ios
+install-name: /usr/lib/libfoo.dylib
+swift-abi-version: 3
+exports:
+  - archs: [ i386, armv7, armv7s ]
+    re-exports: [ /usr/lib/external/liba.dylib ]
+    symbols: [ _sym1, _sym2 ]
+    objc-classes: [ NSString, NSBlockPredicate ]
+    objc-eh-types: [ NSString ]
+    objc-ivars: [ NSBlockPredicate._block ]
+  - archs: [ i386 ]
+    symbols: [ _sym3 ]
+--- !tapi-tbd-v3
+archs: [ armv7, armv7s ]
+platform: ios
+install-name: /usr/lib/liba.dylib
+swift-version: 3
+exports:
+  - archs: [ armv7, armv7s ]
+    symbols: [ _sym10, _sym11 ]
+...

llvm/test/Object/Inputs/tapi-v1.tbd

+--- !tapi-tbd-v1
+
+archs: [ armv7, armv7s ]
+
+platform: ios
+install-name: /u/l/libfoo.dylib
+current-version: 1.2.3
+compatibility-version: 1.0
+swift-version: 0
+objc-constraint: none
+exports:
+ - archs: [ armv7, armv7s ]
+   allowed-clients: [ client ]
+   symbols: [ _sym, ]
+...

llvm/test/Object/Inputs/tapi-v2.tbd

+--- !tapi-tbd-v2
+archs: [ armv7, armv7s, arm64 ]
+uuids: [ "armv7: 00000000-0000-0000-0000-000000000000",
+         "armv7s: 11111111-1111-1111-1111-111111111111",
+         "arm64: 22222222-2222-2222-2222-222222222222" ]
+platform: ios
+flags: [ installapi, flat_namespace ]
+install-name: /u/l/libfoo.dylib
+current-version: 1.2.3
+compatibility-version: 1.0
+swift-version: 0
+objc-constraint: retain_release
+parent-umbrella: Umbrella.dylib
+exports:
+  - archs: [ armv7, armv7s, arm64 ]
+    symbols: [ _sym1, _sym2, _sym3 ]
+
+undefineds:
+  - archs: [ arm64 ]
+    symbols: [ _sym ]
+...

llvm/test/Object/Inputs/tapi-v3.tbd

+--- !tapi-tbd-v3
+archs: [ i386, x86_64 ]
+platform: ios
+install-name: /usr/lib/libfoo.dylib
+swift-abi-version: 3
+exports:
+  - archs: [ i386, x86_64 ]
+    re-exports: [ /usr/lib/external/liba.dylib ]
+    symbols: [ _sym1, _sym2 ]
+    objc-classes: [ NSString, NSBlockPredicate ]
+    objc-eh-types: [ NSString ]
+    objc-ivars: [ NSBlockPredicate._block ]
+  - archs: [ i386 ]
+    symbols: [ _sym3 ]
+--- !tapi-tbd-v3
+archs: [ x86_64 ]
+platform: ios
+install-name: /usr/lib/liba.dylib
+swift-abi-version: 3
+parent-umbrella: foo
+exports:
+  - archs: [ x86_64 ]
+    symbols: [ _sym10, _sym11 ]
+...

llvm/test/Object/Inputs/tapi-v4.tbd

+--- !tapi-tbd
+tbd-version:     4
+targets:         [ i386-ios-simulator, x86_64-ios-simulator ]
+uuids:
+  - target:          i386-ios-simulator
+    value:           00000000-0000-0000-0000-000000000000
+  - target:          x86_64-ios-simulator
+    value:           12FF0E69-DD5A-3356-BB9E-24A133D816F0
+install-name:    '/u/l/libFoo.dylib'
+current-version: 1288
+reexported-libraries:
+  - targets:              [ i386-ios-simulator, x86_64-ios-simulator ]
+    libraries:            [  '/u/l/s/libPrivate.dylib', '/u/l/libPublic.dylib' ]
+exports:
+  - targets:              [ i386-ios-simulator ]
+    symbols:              [ '_sym1' ]
+    weak-symbols:         [ '_sym2' ]
+  - targets:              [ x86_64-ios-simulator, i386-ios-simulator ]
+    symbols:              [ '_sym3', '_sym4' ]
+--- !tapi-tbd
+tbd-version:     4
+targets:         [ i386-ios-simulator, x86_64-ios-simulator ]
+uuids:
+  - target:          i386-ios-simulator
+    value:           2E88EC2B-F951-3D76-B114-F6CC635EFE8C
+  - target:          x86_64-ios-simulator
+    value:           42CD91A1-9824-3FC3-81B2-5355D95C99C7
+install-name:    '/u/l/s/libPrivate.dylib'
+current-version: 60177
+parent-umbrella:
+  - targets:         [ i386-ios-simulator, x86_64-ios-simulator ]
+    umbrella:        Foo 
+exports:
+  - targets:         [ x86_64-ios-simulator ]
+    symbols:         [ '_sym1', '_sym2' ]
+  - targets:         [ x86_64-ios-simulator, i386-ios-simulator ]
+    symbols:         [  '_sym3', '_sym4' ]
+...

llvm/test/Object/nm-tapi-invalids.test

+RUN: not llvm-nm %p/Inputs/tapi-invalid-v1.tbd 2>&1\
+RUN:          | FileCheck %s -check-prefix V1 
+
+RUN: not llvm-nm %p/Inputs/tapi-invalid-v2.tbd 2>&1\
+RUN:          | FileCheck %s -check-prefix V2
+
+RUN: not llvm-nm %p/Inputs/tapi-invalid-v3.tbd 2>&1\
+RUN:          | FileCheck %s -check-prefix V3
+
+# Typo Check
+V1: tapi-invalid-v1.tbd malformed file
+V1-NEXT: tapi-invalid-v1.tbd:12:2: error: unknown key 'expors'
+
+# Missing required key
+V2: tapi-invalid-v2.tbd malformed file
+V2-NEXT: tapi-invalid-v2.tbd:2:1: error: missing required key 'archs'
+
+# v2 key in v3 specified file
+V3: tapi-invalid-v3.tbd malformed file
+V3-NEXT: tapi-invalid-v3.tbd:19:16: error: unknown key 'swift-version'

llvm/test/Object/nm-tapi.test

+RUN: llvm-nm %p/Inputs/tapi-v1.tbd 2>&1\
+RUN:          | FileCheck %s -check-prefix V1
+
+RUN: llvm-nm %p/Inputs/tapi-v2.tbd \
+RUN:          | FileCheck %s -check-prefix V2
+
+RUN: llvm-nm --add-inlinedinfo --arch=x86_64 %p/Inputs/tapi-v3.tbd \
+RUN:          | FileCheck %s -check-prefix V3
+
+RUN: llvm-nm %p/Inputs/tapi-v4.tbd \
+RUN:          | FileCheck %s -check-prefix V4
+
+V1: /u/l/libfoo.dylib (for architecture armv7):
+V1-NEXT: 00000000 S _sym
+V1: /u/l/libfoo.dylib (for architecture armv7s):
+V1-NEXT: 00000000 S _sym
+
+V2: /u/l/libfoo.dylib (for architecture armv7):
+V2-NEXT: 00000000 S _sym1
+V2-NEXT: 00000000 S _sym2
+V2-NEXT: 00000000 S _sym3
+V2: /u/l/libfoo.dylib (for architecture armv7s):
+V2-NEXT: 00000000 S _sym1
+V2-NEXT: 00000000 S _sym2
+V2-NEXT: 00000000 S _sym3
+V2: /u/l/libfoo.dylib (for architecture arm64):
+V2-NEXT:          U _sym
+V2-NEXT: 0000000000000000 S _sym1
+V2-NEXT: 0000000000000000 S _sym2
+V2-NEXT: 0000000000000000 S _sym3
+
+V3: /usr/lib/libfoo.dylib (for architecture x86_64):
+V3-NEXT: 0000000000000000 S _OBJC_CLASS_$_NSBlockPredicate
+V3-NEXT: 0000000000000000 S _OBJC_CLASS_$_NSString
+V3-NEXT: 0000000000000000 S _OBJC_EHTYPE_$_NSString
+V3-NEXT: 0000000000000000 S _OBJC_IVAR_$_NSBlockPredicate._block
+V3-NEXT: 0000000000000000 S _OBJC_METACLASS_$_NSBlockPredicate
+V3-NEXT: 0000000000000000 S _OBJC_METACLASS_$_NSString
+V3-NEXT: 0000000000000000 S _sym1
+V3-NEXT: 0000000000000000 S _sym2
+V3: /usr/lib/liba.dylib (for architecture x86_64):
+V3-NEXT: 0000000000000000 S _OBJC_CLASS_$_NSBlockPredicate
+V3-NEXT: 0000000000000000 S _OBJC_CLASS_$_NSString
+V3-NEXT: 0000000000000000 S _OBJC_EHTYPE_$_NSString
+V3-NEXT: 0000000000000000 S _OBJC_IVAR_$_NSBlockPredicate._block
+V3-NEXT: 0000000000000000 S _OBJC_METACLASS_$_NSBlockPredicate
+V3-NEXT: 0000000000000000 S _OBJC_METACLASS_$_NSString
+V3-NEXT: 0000000000000000 S _sym1
+V3-NEXT: 0000000000000000 S _sym2
+
+V4: /u/l/libFoo.dylib (for architecture i386):
+V4-NEXT: 00000000 S _sym1
+V4-NEXT: 00000000 W _sym2
+V4-NEXT: 00000000 S _sym3
+V4-NEXT: 00000000 S _sym4
+V4: /u/l/libFoo.dylib (for architecture x86_64):
+V4-NEXT: 0000000000000000 S _sym3
+V4-NEXT: 0000000000000000 S _sym4

llvm/tools/llvm-nm/llvm-nm.cpp

 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/IRObjectFile.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
+#include "llvm/Object/TapiFile.h"
+#include "llvm/Object/TapiUniversal.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/Signals.h"
cl::opt<bool> DyldInfoOnly("dyldinfo-only",
                            cl::desc("Show only symbols from the dyldinfo, "
                                     "Mach-O only"),
                            cl::cat(NMCat));
 
 cl::opt<bool> NoLLVMBitcode("no-llvm-bc",
                             cl::desc("Disable LLVM bitcode reader"),
                             cl::cat(NMCat));
 
+cl::opt<bool> AddInlinedInfo("add-inlinedinfo",
+                             cl::desc("Add symbols from the inlined libraries, "
+                                      "TBD(Mach-O) only"),
+                             cl::cat(NMCat));
+
 cl::extrahelp HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
 bool PrintAddress = true;
 
 bool MultipleFiles = false;
 
 bool HadError = false;
 

 
 static char isSymbolList64Bit(SymbolicFile &Obj) {
   if (auto *IRObj = dyn_cast<IRObjectFile>(&Obj))
     return Triple(IRObj->getTargetTriple()).isArch64Bit();
   if (isa<COFFObjectFile>(Obj) || isa<COFFImportFile>(Obj))
     return false;
   if (isa<WasmObjectFile>(Obj))
     return false;
+  if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
+    return Tapi->is64Bit();
   if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
     return MachO->is64Bit();
   return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
 }
 
 static StringRef CurrentFilename;
 static std::vector<NMSymbol> SymbolList;
 
if (SegmentName == "__DATA" && SectionName == "__bss")
       return 'b';
     return 's';
   }
   }
 
   return '?';
 }
 
+static char getSymbolNMTypeChar(TapiFile &Obj, basic_symbol_iterator I) {
+  return 's';
+}
+
 static char getSymbolNMTypeChar(WasmObjectFile &Obj, basic_symbol_iterator I) {
   uint32_t Flags = cantFail(I->getFlags());
   if (Flags & SymbolRef::SF_Executable)
     return 't';
   return 'd';
 }
 
 static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I) {
static char getNMSectionTagAndName(SymbolicFile &Obj, basic_symbol_iterator I,
   else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*COFF, I);
   else if (COFFImportFile *COFFImport = dyn_cast<COFFImportFile>(&Obj))
     Ret = getSymbolNMTypeChar(*COFFImport);
   else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*MachO, I);
   else if (WasmObjectFile *Wasm = dyn_cast<WasmObjectFile>(&Obj))
     Ret = getSymbolNMTypeChar(*Wasm, I);
+  else if (TapiFile *Tapi = dyn_cast<TapiFile>(&Obj))
+    Ret = getSymbolNMTypeChar(*Tapi, I);
   else if (ELFObjectFileBase *ELF = dyn_cast<ELFObjectFileBase>(&Obj)) {
     if (ELFSymbolRef(*I).getELFType() == ELF::STT_GNU_IFUNC)
       return 'i';
     Ret = getSymbolNMTypeChar(*ELF, I);
     if (ELFSymbolRef(*I).getBinding() == ELF::STB_GNU_UNIQUE)
       return Ret;
   } else
     llvm_unreachable("unknown binary format");
for (const MachOUniversalBinary::ObjectForArch &O : UB->objects()) {
         error(Filename + " for architecture " +
               StringRef(O.getArchFlagName()) +
               " is not a Mach-O file or an archive file",
               "Mach-O universal file");
       }
     }
     return;
   }
+
+  if (TapiUniversal *TU = dyn_cast<TapiUniversal>(&Bin)) {
+    for (const TapiUniversal::ObjectForArch &I : TU->objects()) {
+      StringRef ArchName = I.getArchFlagName();
+      const bool ShowArch =
+          ArchFlags.empty() ||
+          any_of(ArchFlags, [&](StringRef Name) { return Name == ArchName; });
+      if (!ShowArch)
+        continue;
+      if (!AddInlinedInfo && !I.isTopLevelLib())
+        continue;
+      if (auto ObjOrErr = I.getAsObjectFile()) {
+        TapiFile &Obj = *ObjOrErr.get();
+        outs() << "\n"
+               << I.getInstallName() << " (for architecture " << ArchName << ")"
+               << ":\n";
+        dumpSymbolNamesFromObject(Obj, false, {}, ArchName);
+      } else if (auto E =
+                     isNotObjectErrorInvalidFileType(ObjOrErr.takeError())) {
+        error(std::move(E), Filename, ArchName);
+      }
+    }
+
+    return;
+  }
+
   if (SymbolicFile *O = dyn_cast<SymbolicFile>(&Bin)) {
     if (!MachOPrintSizeWarning && PrintSize &&  isa<MachOObjectFile>(O)) {
       WithColor::warning(errs(), ToolName)
           << "sizes with --print-size for Mach-O files are always zero.\n";
       MachOPrintSizeWarning = true;
     }
     if (!checkMachOAndArchFlags(O, Filename))
       return;