[clang][llvm] Interface Stubs new yaml file format changes.

[plotfi]

Summary

These file format changes have been a long time coming. Essentially instead of a yaml map mapping trait we now have a sequence. This generally makes the format work better for cases where the symbol list is empty.

[plotfi]

-U999

[plotfi]

Changing some of the version checks. I don't think we need to have rigid checks considering this format is experimental.

[compnerd]

Please address the linter warnings. I think that adding an additional test to demonstrate that the experimental-ifs-version-v1 is properly diagnosed is a good idea. LGTM other than that.

[plotfi]

fixing linter errors

[plotfi]

Adding a better test to check the deprecated v1 format.

[plotfi]

Updating to change im about to land, to see what precommit changes show.

[plotfi]

Trying to fix precommit / clang tidy checks.

clang/lib/Frontend/CompilerInvocation.cpp

if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
     case OPT_emit_header_module:
       Opts.ProgramAction = frontend::GenerateHeaderModule; break;
     case OPT_emit_pch:
       Opts.ProgramAction = frontend::GeneratePCH; break;
     case OPT_emit_interface_stubs: {
       StringRef ArgStr =
           Args.hasArg(OPT_interface_stub_version_EQ)
               ? Args.getLastArgValue(OPT_interface_stub_version_EQ)
-              : "experimental-ifs-v1";
+              : "experimental-ifs-v2";
       if (ArgStr == "experimental-yaml-elf-v1" ||
+          ArgStr ==  "experimental-ifs-v1" ||
           ArgStr == "experimental-tapi-elf-v1") {
         std::string ErrorMessage =
             "Invalid interface stub format: " + ArgStr.str() +
             " is deprecated.";
         Diags.Report(diag::err_drv_invalid_value)
             << "Must specify a valid interface stub format type, ie: "
-               "-interface-stub-version=experimental-ifs-v1"
+               "-interface-stub-version=experimental-ifs-v2"
             << ErrorMessage;
-      } else if (ArgStr != "experimental-ifs-v1") {
+      } else if (!ArgStr.startswith("experimental-ifs-")) {
         std::string ErrorMessage =
             "Invalid interface stub format: " + ArgStr.str() + ".";
         Diags.Report(diag::err_drv_invalid_value)
             << "Must specify a valid interface stub format type, ie: "
-               "-interface-stub-version=experimental-ifs-v1"
+               "-interface-stub-version=experimental-ifs-v2"
             << ErrorMessage;
       } else {
-        Opts.ProgramAction = frontend::GenerateInterfaceIfsExpV1;
+        Opts.ProgramAction = frontend::GenerateInterfaceStubs;
       }
       break;
     }
     case OPT_init_only:
       Opts.ProgramAction = frontend::InitOnly; break;
     case OPT_fsyntax_only:
       Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
     case OPT_module_file_info:
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
   case frontend::EmitLLVMOnly:
   case frontend::EmitCodeGenOnly:
   case frontend::EmitObj:
   case frontend::FixIt:
   case frontend::GenerateModule:
   case frontend::GenerateModuleInterface:
   case frontend::GenerateHeaderModule:
   case frontend::GeneratePCH:
-  case frontend::GenerateInterfaceIfsExpV1:
+  case frontend::GenerateInterfaceStubs:
   case frontend::ParseSyntaxOnly:
   case frontend::ModuleFileInfo:
   case frontend::VerifyPCH:
   case frontend::PluginAction:
   case frontend::RewriteObjC:
   case frontend::RewriteTest:
   case frontend::RunAnalysis:
   case frontend::TemplightDump:

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

void HandleTranslationUnit(ASTContext &context) override {
     for (const NamedDecl *ND : v.NamedDecls)
       HandleNamedDecl(ND, Symbols, FromTU);
 
     auto writeIfsV1 = [this](const llvm::Triple &T,
                              const MangledSymbols &Symbols,
                              const ASTContext &context, StringRef Format,
                              raw_ostream &OS) -> void {
       OS << "--- !" << Format << "\n";
-      OS << "IfsVersion: 1.0\n";
+      OS << "IfsVersion: 2.0\n";
       OS << "Triple: " << T.str() << "\n";
       OS << "ObjectFileFormat: "
          << "ELF"
          << "\n"; // TODO: For now, just ELF.
       OS << "Symbols:\n";
       for (const auto &E : Symbols) {
         const MangledSymbol &Symbol = E.second;
         for (auto Name : Symbol.Names) {
-          OS << "  \""
+          OS << "  - { Name: \""
              << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
                      ? ""
                      : (Symbol.ParentName + "."))
-             << Name << "\" : { Type: ";
+             << Name << "\", Type: ";
           switch (Symbol.Type) {
           default:
             llvm_unreachable(
                 "clang -emit-interface-stubs: Unexpected symbol type.");
           case llvm::ELF::STT_NOTYPE:
             OS << "NoType";
             break;
           case llvm::ELF::STT_OBJECT: {
auto writeIfsV1 = [this](const llvm::Triple &T,
             OS << ", Weak: true";
           OS << " }\n";
         }
       }
       OS << "...\n";
       OS.flush();
     };
 
-    assert(Format == "experimental-ifs-v1" && "Unexpected IFS Format.");
+    assert(Format == "experimental-ifs-v2" && "Unexpected IFS Format.");
     writeIfsV1(Instance.getTarget().getTriple(), Symbols, context, Format, *OS);
   }
 };
 } // namespace
 
 std::unique_ptr<ASTConsumer>
-GenerateInterfaceIfsExpV1Action::CreateASTConsumer(CompilerInstance &CI,
-                                                   StringRef InFile) {
+GenerateInterfaceStubsAction::CreateASTConsumer(CompilerInstance &CI,
   return std::make_unique<InterfaceStubFunctionsConsumer>(
-      CI, InFile, "experimental-ifs-v1");
+      CI, InFile, "experimental-ifs-v2");
 }

clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

CreateFrontendBaseAction(CompilerInstance &CI) {
   case FixIt:                  return std::make_unique<FixItAction>();
   case GenerateModule:
     return std::make_unique<GenerateModuleFromModuleMapAction>();
   case GenerateModuleInterface:
     return std::make_unique<GenerateModuleInterfaceAction>();
   case GenerateHeaderModule:
     return std::make_unique<GenerateHeaderModuleAction>();
   case GeneratePCH:            return std::make_unique<GeneratePCHAction>();
-  case GenerateInterfaceIfsExpV1:
-    return std::make_unique<GenerateInterfaceIfsExpV1Action>();
+  case GenerateInterfaceStubs:
+    return std::make_unique<GenerateInterfaceStubsAction>();
   case InitOnly:               return std::make_unique<InitOnlyAction>();
   case ParseSyntaxOnly:        return std::make_unique<SyntaxOnlyAction>();
   case ModuleFileInfo:         return std::make_unique<DumpModuleInfoAction>();
   case VerifyPCH:              return std::make_unique<VerifyPCHAction>();
   case TemplightDump:          return std::make_unique<TemplightDumpAction>();
 
   case PluginAction: {
     for (FrontendPluginRegistry::iterator it =

clang/test/InterfaceStubs/bad-format.cpp

 
 // RUN: not %clang -emit-interface-stubs \
 // RUN: -interface-stub-version=experimental-yaml-elf-v1 %s 2>&1 | \
 // RUN: FileCheck -check-prefix=CHECK-YAML-DEPRECATED %s
 
 // CHECK: error: invalid value
 // CHECK: 'Invalid interface stub format: bad-format.' in 'Must specify a
 // CHECK: valid interface stub format type, ie:
-// CHECK: -interface-stub-version=experimental-ifs-v1'
+// CHECK: -interface-stub-version=experimental-ifs-v2'
 
 // CHECK-TAPI-DEPRECATED: error: invalid value
 // CHECK-TAPI-DEPRECATED: 'Invalid interface stub format:
 // CHECK-TAPI-DEPRECATED: experimental-tapi-elf-v1 is deprecated.' in 'Must
 // CHECK-TAPI-DEPRECATED: specify a valid interface stub format type, ie:
-// CHECK-TAPI-DEPRECATED: -interface-stub-version=experimental-ifs-v1'
+// CHECK-TAPI-DEPRECATED: -interface-stub-version=experimental-ifs-v2'
 
 // CHECK-YAML-DEPRECATED: error: invalid value
 // CHECK-YAML-DEPRECATED: 'Invalid interface stub format:
 // CHECK-YAML-DEPRECATED: experimental-yaml-elf-v1 is deprecated.' in 'Must
 // CHECK-YAML-DEPRECATED: specify a valid interface stub format type, ie:
-// CHECK-YAML-DEPRECATED: -interface-stub-version=experimental-ifs-v1'
+// CHECK-YAML-DEPRECATED: -interface-stub-version=experimental-ifs-v2'

clang/test/InterfaceStubs/blocks.c

 // RUN: %clang_cc1 -emit-interface-stubs -fblocks -o - %s | FileCheck %s
 
-// CHECK: --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK: --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 static void (^f)(void*) = ^(void* data) { int i; };

clang/test/InterfaceStubs/class-template-partial-specialization.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<typename> struct S7 { };
 template<typename T> struct S7<T&> { };

clang/test/InterfaceStubs/conflict-type.ifs

 # RUN: not %clang -emit-merged-ifs -emit-interface-stubs -o - %s %S/func.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # Here we are testing to see if two symbols with identical names will fail to
 # merge in conflict due to mismatched types.
 # CHECK-IFS: error: Interface Stub: Type Mismatch for a.
 # CHECK-IFS-NEXT: Filename:
 # CHECK-IFS-NEXT: Type Values: Object Func
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a: { Type: Object, Size: 1 }
+  - { Name: a, Type: Object, Size: 1 }
 ...

clang/test/InterfaceStubs/constructor-using-shadow.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
  // ConstructorUsingShadowDecl
 struct Base { Base(int); };
 struct Derived : public Base { using Base::Base; };

clang/test/InterfaceStubs/cxx-conversion.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<typename T> class C1 {
     long a;
     operator long() const { return a; }
 };

clang/test/InterfaceStubs/cxxdeduction-guide.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs -std=c++17 %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 // CXXDeductionGuideDecl
 template<typename T> struct A { A(); A(T); };
 A() -> A<int>;

clang/test/InterfaceStubs/driver-test3.c

 // REQUIRES: x86-registered-target
 // REQUIRES: shell
 
 // RUN: mkdir -p %t; cd %t
 // RUN: %clang -target x86_64-unknown-linux-gnu -c -emit-interface-stubs %s -o %t/driver-test3.o
 // RUN: llvm-nm %t/driver-test3.o | FileCheck --check-prefix=CHECK-OBJ %s
 // RUN: cat %t/driver-test3.ifs | FileCheck --check-prefix=CHECK-IFS %s
 
 // CHECK-OBJ: bar
 
-// CHECK-IFS: --- !experimental-ifs-v1
+// CHECK-IFS: --- !experimental-ifs-v2
 // CHECK-IFS-NEXT: IfsVersion:
 // CHECK-IFS-NEXT: Triple:
 // CHECK-IFS-NEXT: ObjectFileFormat:
 // CHECK-IFS-NEXT: Symbols:
-// CHECK-IFS-NEXT:   "bar" : { Type: Func }
+// CHECK-IFS-NEXT:   - { Name: "bar", Type: Func }
 // CHECK-IFS-NEXT: ...
 
 int bar(int a) { return a; }

clang/test/InterfaceStubs/empty.c

+// RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
+
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
+// CHECK-NEXT: Triple:
+// CHECK-NEXT: ObjectFileFormat:
+// CHECK-NEXT: Symbols:
+// CHECK-NEXT: ...

clang/test/InterfaceStubs/func.ifs

 # RUN: %clang -emit-interface-stubs -o - %s %S/object.ifs -emit-merged-ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # RUN: %clang -emit-interface-stubs -o - %s %S/object.ifs | llvm-readelf --all | \
 # RUN: FileCheck %s --check-prefixes=CHECK-ELF
 
 # RUN: %clang -emit-interface-stubs -o - %s %s -emit-merged-ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion:      1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple:          x86_64-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-DAG:   a:               { Type: Func }
-# CHECK-IFS-DAG:   b:               { Type: Object, Size: 4 }
+# CHECK-IFS-DAG:   - { Name: a, Type: Func }
+# CHECK-IFS-DAG:   - { Name: b, Type: Object, Size: 4 }
 # CHECK-IFS: ...
 
 # CHECK-ELF: ELF Header:
 # CHECK-ELF:   Class:                             ELF64
 # CHECK-ELF:   Type:                              DYN (Shared object file)
 # CHECK-ELF:   FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF:   OBJECT  GLOBAL DEFAULT  1 b
 
 # Here we are testing to see if two identical symbols will merge.
-# CHECK-MERGE-IFS: --- !experimental-ifs-v1
-# CHECK-MERGE-IFS-NEXT: IfsVersion:      1.0
+# CHECK-MERGE-IFS: --- !experimental-ifs-v2
+# CHECK-MERGE-IFS-NEXT: IfsVersion: 2.0
 # CHECK-MERGE-IFS-NEXT: Triple:          x86_64-linux-gnu
 # CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-MERGE-IFS-NEXT: Symbols:
-# CHECK-MERGE-IFS-NEXT:   a:               { Type: Func }
+# CHECK-MERGE-IFS-NEXT:   - { Name: a, Type: Func }
 # CHECK-MERGE-IFS-NEXT: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a: { Type: Func }
+  - { Name: a, Type: Func }
 ...

clang/test/InterfaceStubs/hidden-class-inheritance.cpp

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \
 // RUN: -DPARENT_CLASS_VISIBILITY="" -DCHILD_CLASS_VISIBILITY="" \
 // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
 // RUN: FileCheck -check-prefix=CHECK-X %s
 // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c \
 // RUN: -DPARENT_CLASS_VISIBILITY="" -DCHILD_CLASS_VISIBILITY="" \
 // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
 // RUN: llvm-readelf -s - 2>&1 | \
 // RUN: FileCheck -check-prefix=CHECK-X-RE %s
 
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \
 // RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \
 // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
 // RUN: FileCheck -check-prefix=CHECK-HP %s
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs \
-// RUN: -interface-stub-version=experimental-ifs-v1 \
+// RUN: -interface-stub-version=experimental-ifs-v2 \
 // RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \
 // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
 // RUN: FileCheck -check-prefix=CHECK-HP2 %s
 // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c \
 // RUN: -DPARENT_CLASS_VISIBILITY=HIDDEN -DCHILD_CLASS_VISIBILITY="" \
 // RUN: -DPARENT_METHOD_VISIBILITY="" -DCHILD_METHOD_VISIBILITY="" %s | \
 // RUN: llvm-readelf -s - 2>&1 | \
 // RUN: FileCheck -check-prefix=CHECK-HP-RE %s

clang/test/InterfaceStubs/indirect-field-decl.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<typename T> class C2 { union { T c; }; };

clang/test/InterfaceStubs/inline.c

 
 // RUN: %clang_cc1 -DINLINE=inline -triple x86_64-linux-gnu -o - \
 // RUN: -emit-interface-stubs \
 // RUN: -std=gnu89 -xc %s | FileCheck -check-prefix=CHECK-SYMBOLS %s
 // RUN: %clang -DINLINE=inline -target x86_64-linux-gnu -o - \
 // RUN: -c -std=gnu89 -xc %s | llvm-nm - 2>&1 | \
 // RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s
 
-// CHECK-TAPI-DAG: foo" : { Type: Func }
-// CHECK-TAPI-DAG: foo.var" : { Type: Object, Size: 4 }
+// CHECK-TAPI-DAG: foo", Type: Func }
+// CHECK-TAPI-DAG: foo.var",  Type: Object, Size: 4 }
 // CHECK-SYMBOLS-DAG: foo
 // CHECK-SYMBOLS-DAG: foo.var
 #include "inline.h"

clang/test/InterfaceStubs/lambda.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -emit-interface-stubs -o - %s \
 // RUN:     | FileCheck %s
 
-// CHECK: --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK: --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
-// CHECK-NEXT:   f" : { Type: Object, Size: 1 }
+// CHECK-NEXT:   f", Type: Object, Size: 1 }
 // CHECK-NEXT: ...
 auto f = [](void* data) { int i; };

clang/test/InterfaceStubs/namespace-alias.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 // NamespaceAliasDecl
 namespace NS { }
 namespace B = NS;

clang/test/InterfaceStubs/namespace.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 namespace NS1 { }
 using namespace NS1;

clang/test/InterfaceStubs/non-type-template-parm-decl.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<bool T> struct S1 {};

clang/test/InterfaceStubs/object.c

 // RUN: %clang_cc1 -fvisibility default -o - -emit-interface-stubs %s | FileCheck -check-prefix=CHECK-TAPI %s
 // RUN: %clang -fvisibility=default -c -o - %s | llvm-nm - 2>&1 | FileCheck -check-prefix=CHECK-SYMBOLS %s
 
-// CHECK-TAPI: data" : { Type: Object, Size: 4 }
+// CHECK-TAPI: data", Type: Object, Size: 4 }
 // CHECK-SYMBOLS: data
 int data = 42;

clang/test/InterfaceStubs/object.ifs

 # RUN: %clang -emit-interface-stubs -o - -emit-merged-ifs %s | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # RUN: %clang -emit-interface-stubs -o - %s | llvm-readelf --all | \
 # RUN: FileCheck %s --check-prefixes=CHECK-ELF
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion:      1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple: x86_64-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-NEXT:   b:               { Type: Object, Size: 4 }
+# CHECK-IFS-NEXT:   - { Name: b, Type: Object, Size: 4 }
 # CHECK-IFS-NEXT: ...
 
 # CHECK-ELF: ELF Header:
 # CHECK-ELF:   Class:                             ELF64
 # CHECK-ELF:   Data:                              2's complement, little endian
 # CHECK-ELF:   Type:                              DYN (Shared object file)
 # CHECK-ELF-NOT:   FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF:   OBJECT  GLOBAL DEFAULT  1 b
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  b: { Type: Object, Size: 4 }
+  - { Name: b, Type: Object, Size: 4 }
 ...

clang/test/InterfaceStubs/ppc.cpp

 // REQUIRES: powerpc-registered-target
 
 // RUN: %clang -x c++ -target powerpc64le-unknown-linux-gnu -o - %s \
 // RUN:   -emit-interface-stubs -emit-merged-ifs -S | \
 // RUN: FileCheck -check-prefix=CHECK-IFS %s
 
- // CHECK-IFS: --- !experimental-ifs-v1
- // CHECK-IFS: IfsVersion:      1.0
+ // CHECK-IFS: --- !experimental-ifs-v2
+ // CHECK-IFS: IfsVersion: 2.0
  // CHECK-IFS: Triple: powerpc64le
  // CHECK-IFS: Symbols:
- // CHECK-IFS:   _Z8helloPPCv: { Type: Func }
+ // CHECK-IFS:   - { Name: _Z8helloPPCv, Type: Func }
  // CHECK-IFS: ...
 
 int helloPPC();

clang/test/InterfaceStubs/template-constexpr.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<typename T, T v> struct S8 { static constexpr T value = v; };
 template<typename T, T v> constexpr T S8<T, v>::value;

clang/test/InterfaceStubs/template-namespace-function.cpp

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs %s | \
 // RUN: FileCheck %s
 
 // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c %s | llvm-nm - 2>&1 | \
 // RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s
 
 // CHECK: Symbols:
-// CHECK-DAG:  "_ZN3qux3barEii" : { Type: Func }
-// CHECK-DAG:  "_ZN3baz3addIiEET_S1_S1_" : { Type: Func }
-// CHECK-DAG:  "_Z4fbarff" : { Type: Func }
-// CHECK-DAG:  "_ZN3baz3addIfEET_S1_S1_" : { Type: Func }
+// CHECK-DAG:  - { Name: "_ZN3qux3barEii", Type: Func }
+// CHECK-DAG:  - { Name: "_ZN3baz3addIiEET_S1_S1_",  Type: Func }
+// CHECK-DAG:  - { Name: "_Z4fbarff", Type: Func }
+// CHECK-DAG:  - { Name: "_ZN3baz3addIfEET_S1_S1_", Type: Func }
 
 // Same symbols just different order.
 // CHECK-SYMBOLS-DAG:  _Z4fbarff
 // CHECK-SYMBOLS-DAG:  _ZN3baz3addIfEET_S1_S1_
 // CHECK-SYMBOLS-DAG:  _ZN3baz3addIiEET_S1_S1_
 // CHECK-SYMBOLS-DAG:  _ZN3qux3barEii
 
 namespace baz {

clang/test/InterfaceStubs/template-template-parm-decl.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<template<typename...> class a> struct S6 { };

clang/test/InterfaceStubs/trycatch.cpp

 // REQUIRES: x86-registered-target
 
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -o - -emit-interface-stubs %s | FileCheck %s
 
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
-// CHECK-NEXT: "_Z1fv" : { Type: Func }
+// CHECK-NEXT: - { Name: "_Z1fv", Type: Func }
 // CHECK-NEXT: ...
 
 class C5 {};
 void f() { try {} catch(C5&){} }

clang/test/InterfaceStubs/unresolved-using-typename.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 // UnresolvedUsingTypenameDecl
 template<typename T> class C1 { using ReprType = unsigned; };
 template<typename T> class C2 : public C1<T> { using typename C1<T>::Repr; };

clang/test/InterfaceStubs/usings.cpp

 // RUN: %clang_cc1 -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple:
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
 // CHECK-NEXT: ...
 
 template<typename T> struct S2 { static unsigned f(); };
 template<typename T> struct S3  { using S2<T>::f; };
 
 typedef struct {} S4;
 using ::S4;
 
 template<typename T, T t> struct C3{};
 template<bool b> using U1 = C3<bool, b>;

clang/test/InterfaceStubs/var-template-specialization-decl.cpp

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -o - -emit-interface-stubs %s | FileCheck %s
 
-// CHECK:      --- !experimental-ifs-v1
-// CHECK-NEXT: IfsVersion: 1.0
+// CHECK:      --- !experimental-ifs-v2
+// CHECK-NEXT: IfsVersion: 2.0
 // CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
 // CHECK-NEXT: ObjectFileFormat: ELF
 // CHECK-NEXT: Symbols:
-// CHECK-NEXT: "a" : { Type: Object, Size: 4 }
+// CHECK-NEXT: - { Name: "a", Type: Object, Size: 4 }
 // CHECK-NEXT: ...
 
 template<typename T, T v> struct S9 {
     static constexpr T value = v;
 };
 template<typename T> struct S0 : public S9<bool, true> { };
 template<typename T> constexpr bool CE2 = S0<T>::value;
 int a = CE2<int>;

clang/test/InterfaceStubs/weak.cpp

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 -triple x86_64-linux-gnu -o - -emit-interface-stubs \
-// RUN: -interface-stub-version=experimental-ifs-v1 %s | \
+// RUN: -interface-stub-version=experimental-ifs-v2 %s | \
 // RUN: FileCheck %s
 
 // RUN: %clang -target x86_64-unknown-linux-gnu -o - -c %s | llvm-nm - 2>&1 | \
 // RUN: FileCheck -check-prefix=CHECK-SYMBOLS %s
 
 // CHECK: Symbols:
-// CHECK-DAG:  "_Z8weakFuncv" : { Type: Func, Weak: true }
-// CHECK-DAG:  "_Z10strongFuncv" : { Type: Func }
+// CHECK-DAG:  - { Name: "_Z8weakFuncv", Type: Func, Weak: true }
+// CHECK-DAG:  - { Name: "_Z10strongFuncv", Type: Func }
 
 // CHECK-SYMBOLS-DAG: _Z10strongFuncv
 // CHECK-SYMBOLS-DAG: _Z8weakFuncv
 __attribute__((weak)) void weakFunc() {}
 int strongFunc() { return 42; }

clang/test/InterfaceStubs/windows.cpp

 // REQUIRES: x86-registered-target
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -o - %s -emit-interface-stubs | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: %clang -target x86_64-windows-msvc -o - %s -emit-interface-stubs -emit-merged-ifs -S | FileCheck -check-prefix=CHECK-IFS %s
 // note: -S is added here to prevent clang from invoking link.exe
 
 // CHECK-CC1: Symbols:
 // CHECK-CC1-NEXT: ?helloWindowsMsvc@@YAHXZ
 
- // CHECK-IFS: --- !experimental-ifs-v1
- // CHECK-IFS: IfsVersion:      1.0
+ // CHECK-IFS: --- !experimental-ifs-v2
+ // CHECK-IFS: IfsVersion: 2.0
  // CHECK-IFS: Triple:
  // CHECK-IFS: Symbols:
- // CHECK-IFS:   ?helloWindowsMsvc@@YAHXZ: { Type: Func }
+ // CHECK-IFS:   - { Name: '?helloWindowsMsvc@@YAHXZ', Type: Func }
  // CHECK-IFS: ...
 
 int helloWindowsMsvc();

llvm/test/tools/llvm-ifs/Inputs/strong-mismatch-size.ifs

 # NOTE: Used by weak-mismatch.ifs
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  foobar: { Type: Object, Size: 2 }
+  - { Name: foobar, Type: Object, Size: 2 }
 ...

llvm/test/tools/llvm-ifs/Inputs/strong-mismatch-type.ifs

 # NOTE: Used by weak-mismatch.ifs
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  foobar: { Type: Func }
+  - { Name: foobar, Type: Func }
 ...

llvm/test/tools/llvm-ifs/conflict-header-format.ifs

 # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # CHECK-IFS: error: Interface Stub: ObjectFileFormat Mismatch.
 # CHECK-IFS-NEXT: Filenames:
 # CHECK-IFS-NEXT: ObjectFileFormat Values: TBD ELF
 
---- !experimental-ifs-v1
-IfsVersion:      1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple:          x86_64-apple-unknown
 ObjectFileFormat: TBD
 Symbols:
-  a:               { Type: Func }
+  - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/conflict-header-triple.ifs

 # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # CHECK-IFS: error: Interface Stub: Triple Mismatch.
 # CHECK-IFS-NEXT: Filenames:
 # CHECK-IFS-NEXT: Triple Values: mips-unknown-linux x86_64-unknown-linux-gnu
 
---- !experimental-ifs-v1
-IfsVersion:      1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple:          mips-unknown-linux
 ObjectFileFormat: ELF
 Symbols:
-  a:               { Type: Func }
+  - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/conflict-header-version.ifs

 # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # RUN: not llvm-ifs -action write-ifs -o - %s 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS2
 
 # CHECK-IFS: error: Interface Stub: IfsVersion Mismatch.
-# CHECK-IFS2: error: Interface Stub: Bad IfsVersion: 0.0, llvm-ifs supported version: 1.2.
+# CHECK-IFS2: error: Interface Stub: Bad IfsVersion: 0.0, llvm-ifs supported version: 2.0.
 
---- !experimental-ifs-v1
+--- !experimental-ifs-v2
 IfsVersion:      0.0
 Triple:          x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a:               { Type: Func }
+  - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/conflict-size.ifs

 # RUN: not llvm-ifs -action write-ifs -o - %s %S/object.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # Here we are testing to see if two symbols with identical names will fail to
 # merge in conflict due to mismatching sizes.
 # CHECK-IFS: error: Interface Stub: Size Mismatch for b.
 # CHECK-IFS-NEXT: Filename:
 # CHECK-IFS-NEXT: Size Values: 1 4
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  b: { Type: Object, Size: 1 }
+  - { Name: b, Type: Object, Size: 1 }
 ...

llvm/test/tools/llvm-ifs/conflict-type.ifs

 # RUN: not llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # Here we are testing to see if two symbols with identical names will fail to
 # merge in conflict due to mismatched types.
 # CHECK-IFS: error: Interface Stub: Type Mismatch for a.
 # CHECK-IFS-NEXT: Filename:
 # CHECK-IFS-NEXT: Type Values: Object Func
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a: { Type: Object, Size: 1 }
+  - { Name: a, Type: Object, Size: 1 }
 ...

llvm/test/tools/llvm-ifs/conflict-weak.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs 2>&1 | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # CHECK-IFS: Symbols:
-# CHECK-IFS-NEXT: a: { Type: Func, Weak: true }
+# CHECK-IFS-NEXT: - { Name: a, Type: Func, Weak: true }
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a: { Type: Func, Weak: true }
+  - { Name: a, Type: Func, Weak: true }
 ...

llvm/test/tools/llvm-ifs/default-empty.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s | FileCheck --check-prefixes=CHECK-DEFAULT %s
 # RUN: llvm-ifs -action write-ifs -o - %s %S/weak.ifs | FileCheck --check-prefixes=CHECK-MERGE %s
 
-# CHECK-DEFAULT: --- !experimental-ifs-v1
-# CHECK-DEFAULT-NEXT: IfsVersion:      1.2
+# CHECK-DEFAULT: --- !experimental-ifs-v2
+# CHECK-DEFAULT-NEXT: IfsVersion: 2.0
 # CHECK-DEFAULT-NEXT: Triple:          ''
 # CHECK-DEFAULT-NEXT: ObjectFileFormat: ELF
-# CHECK-DEFAULT-NEXT: Symbols:         {}
+# CHECK-DEFAULT-NEXT: Symbols:         []
 # CHECK-DEFAULT-NEXT: ...
 
-# CHECK-MERGE: --- !experimental-ifs-v1
-# CHECK-MERGE-NEXT: IfsVersion: 1.0
+# CHECK-MERGE: --- !experimental-ifs-v2
+# CHECK-MERGE-NEXT: IfsVersion: 2.0
 # CHECK-MERGE-NEXT: Triple: x86_64-unknown-linux-gnu
 # CHECK-MERGE-NEXT: ObjectFileFormat: ELF
 # CHECK-MERGE-NEXT: Symbols:
-# CHECK-MERGE-DAG:   _Z8weakFuncv: { Type: Func, Weak: true }
-# CHECK-MERGE-DAG:   _Z10strongFuncv: { Type: Func }
+# CHECK-MERGE-DAG:  - { Name: _Z8weakFuncv, Type: Func, Weak: true }
+# CHECK-MERGE-DAG:  - { Name: _Z10strongFuncv, Type: Func }
 # CHECK-MERGE: ...
 
---- !experimental-ifs-v1
-IfsVersion:      1.2
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple:          ''
 ObjectFileFormat: ELF
-Symbols:         {}
+Symbols:         []
 ...

llvm/test/tools/llvm-ifs/empty1.ifs

+# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s
+
+# CHECK: --- !experimental-ifs-v2
+# CHECK-NEXT: IfsVersion: 2.0
+# CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
+# CHECK-NEXT: ObjectFileFormat: ELF
+# CHECK-NEXT: Symbols: []
+# CHECK: ...
+
+--- !experimental-ifs-v2
+IfsVersion:      2.0
+Triple:          x86_64-unknown-linux-gnu
+ObjectFileFormat: ELF
+Symbols:         []
+...

llvm/test/tools/llvm-ifs/empty2.ifs

+# RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s
+
+# CHECK: --- !experimental-ifs-v2
+# CHECK-NEXT: IfsVersion: 2.0
+# CHECK-NEXT: Triple: x86_64-unknown-linux-gnu
+# CHECK-NEXT: ObjectFileFormat: ELF
+# CHECK-NEXT: Symbols: []
+# CHECK: ...
+
+--- !experimental-ifs-v2
+IfsVersion:      2.0
+Triple:          x86_64-unknown-linux-gnu
+ObjectFileFormat: ELF
+Symbols:
+...

llvm/test/tools/llvm-ifs/func.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # RUN: llvm-ifs -action write-bin -o - %s %S/object.ifs | \
 # RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF
 
 # RUN: llvm-ifs -action write-bin -force-format TBD -o - %s %S/object.ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-DARWIN-TBD3
 
 # RUN: llvm-ifs -action write-ifs -o - %s %s | \
 # RUN: FileCheck %s --check-prefixes=CHECK-MERGE-IFS
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion:      1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-DAG:   a:               { Type: Func }
-# CHECK-IFS-DAG:   b:               { Type: Object, Size: 4 }
+# CHECK-IFS-DAG:   - { Name: a, Type: Func }
+# CHECK-IFS-DAG:   - { Name: b, Type: Object, Size: 4 }
 # CHECK-IFS: ...
 
 # CHECK-ELF: ELF Header:
 # CHECK-ELF:   Class:                             ELF64
 # CHECK-ELF:   Type:                              DYN (Shared object file)
 # CHECK-ELF:   FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF:   OBJECT  GLOBAL DEFAULT  1 b
 
 # CHECK-DARWIN-TBD3: --- !tapi-tbd-v3
 # CHECK-DARWIN-TBD3-NEXT: archs:           [ x86_64 ]
 # CHECK-DARWIN-TBD3-NEXT: platform:        macosx
 # CHECK-DARWIN-TBD3-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-DARWIN-TBD3-NEXT: install-name:    ''
 # CHECK-DARWIN-TBD3-NEXT: current-version: 0
 # CHECK-DARWIN-TBD3-NEXT: compatibility-version: 0
 # CHECK-DARWIN-TBD3-NEXT: objc-constraint: none
 # CHECK-DARWIN-TBD3-NEXT: exports:
 # CHECK-DARWIN-TBD3-NEXT:   - archs:           [ x86_64 ]
 # CHECK-DARWIN-TBD3-NEXT:     symbols:         [ a, b ]
 # CHECK-DARWIN-TBD3-NEXT: ...
 
 # Here we are testing to see if two identical symbols will merge.
-# CHECK-MERGE-IFS: --- !experimental-ifs-v1
-# CHECK-MERGE-IFS-NEXT: IfsVersion:      1.0
+# CHECK-MERGE-IFS: --- !experimental-ifs-v2
+# CHECK-MERGE-IFS-NEXT: IfsVersion: 2.0
 # CHECK-MERGE-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
 # CHECK-MERGE-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-MERGE-IFS-NEXT: Symbols:
-# CHECK-MERGE-IFS-NEXT:   a:               { Type: Func }
+# CHECK-MERGE-IFS-NEXT:   - { Name: a, Type: Func }
 # CHECK-MERGE-IFS-NEXT: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a: { Type: Func }
+  - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/ios-tbd.ifs

 # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        ios
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: arm64-apple-ios
 ObjectFileFormat: TBD
 Symbols:
-  __Z3fooi: { Type: Func }
+  - { Name: __Z3fooi, Type: Func }
 ...

llvm/test/tools/llvm-ifs/macos-tbd.ifs

 # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        macosx
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: arm64-apple-macosx
 ObjectFileFormat: TBD
 Symbols:
-  __Z3fooi: { Type: Func }
+  - { Name: __Z3fooi, Type: Func }
 ...

llvm/test/tools/llvm-ifs/object-function-size-weak-combo.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # RUN: llvm-ifs -action write-bin -o - %s %S/func.ifs %S/object.ifs %S/weak.ifs | \
 # RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion:      1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-DAG:   e:               { Type: Object, Size: 8 }
-# CHECK-IFS-DAG:   a:               { Type: Func }
-# CHECK-IFS-DAG:   f:               { Type: Object, Size: 2 }
-# CHECK-IFS-DAG:   _Z10strongFuncv: { Type: Func }
-# CHECK-IFS-DAG:   _Z8weakFuncv:    { Type: Func, Weak: true }
-# CHECK-IFS-DAG:   b:               { Type: Object, Size: 4 }
+# CHECK-IFS-DAG:   - { Name: e,              Type: Object, Size: 8 }
+# CHECK-IFS-DAG:   - { Name: a,              Type: Func }
+# CHECK-IFS-DAG:   - { Name: f,              Type: Object, Size: 2 }
+# CHECK-IFS-DAG:   - { Name: _Z10strongFuncv, Type: Func }
+# CHECK-IFS-DAG:   - { Name: _Z8weakFuncv,   Type: Func, Weak: true }
+# CHECK-IFS-DAG:   - { Name: b,              Type: Object, Size: 4 }
 # CHECK-IFS: ...
 
 # CHECK-ELF: FUNC    GLOBAL DEFAULT  1 _Z10strongFuncv
 # CHECK-ELF: FUNC    WEAK   DEFAULT  1 _Z8weakFuncv
 # CHECK-ELF: FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF: OBJECT  GLOBAL DEFAULT  1 b
 # CHECK-ELF: OBJECT  GLOBAL DEFAULT  1 e
 # CHECK-ELF: OBJECT  GLOBAL DEFAULT  1 f
 
---- !experimental-ifs-v1
-IfsVersion:      1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple:          x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  e:               { Type: Object, Size: 8 }
-  f:               { Type: Object, Size: 2 }
+  - { Name: e, Type: Object, Size: 8 }
+  - { Name: f, Type: Object, Size: 2 }
 ...

llvm/test/tools/llvm-ifs/object.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s | \
 # RUN: FileCheck %s --check-prefixes=CHECK-IFS
 
 # RUN: llvm-ifs -action write-bin -o - %s | \
 # RUN: llvm-readelf --all | FileCheck %s --check-prefixes=CHECK-ELF
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion:      1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple:          x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-NEXT:   b:               { Type: Object, Size: 4 }
+# CHECK-IFS-NEXT:   - { Name: b, Type: Object, Size: 4 }
 # CHECK-IFS-NEXT: ...
 
 # CHECK-ELF: ELF Header:
 # CHECK-ELF:   Class:                             ELF64
 # CHECK-ELF:   Data:                              2's complement, little endian
 # CHECK-ELF:   Type:                              DYN (Shared object file)
 # CHECK-ELF-NOT:   FUNC    GLOBAL DEFAULT  1 a
 # CHECK-ELF:   OBJECT  GLOBAL DEFAULT  1 b
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  b: { Type: Object, Size: 4 }
+  - { Name: b, Type: Object, Size: 4 }
 ...

llvm/test/tools/llvm-ifs/strong.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s %S/strong.ifs | FileCheck %s --check-prefixes=CHECK-IFS
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion: 1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-DAG:   _Z8weakFuncv: { Type: Func }
+# CHECK-IFS-DAG:   - { Name: _Z8weakFuncv, Type: Func }
 # CHECK-IFS: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  _Z8weakFuncv: { Type: Func }
+  - { Name: _Z8weakFuncv, Type: Func }
 ...

llvm/test/tools/llvm-ifs/tvos-tbd.ifs

 # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        tvos
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: arm64-apple-tvos
 ObjectFileFormat: TBD
 Symbols:
-  __Z3fooi: { Type: Func }
+  - { Name: __Z3fooi, Type: Func }
 ...

llvm/test/tools/llvm-ifs/version-ok.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s %S/object.ifs
 
---- !experimental-ifs-v1
-IfsVersion:      1.1
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple:          x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  a:               { Type: Func }
+  - { Name: a, Type: Func }
 ...

llvm/test/tools/llvm-ifs/watchos-tbd.ifs

 # RUN: llvm-ifs --action write-bin -o - %s | FileCheck %s
 
 # CHECK: --- !tapi-tbd-v3
 # CHECK-NEXT: archs:           [ arm64 ]
 # CHECK-NEXT: platform:        watchos
 # CHECK-NEXT: flags:           [ flat_namespace, not_app_extension_safe ]
 # CHECK-NEXT: install-name:    ''
 # CHECK-NEXT: current-version: 0
 # CHECK-NEXT: compatibility-version: 0
 # CHECK-NEXT: objc-constraint: none
 # CHECK-NEXT: exports:
 # CHECK-NEXT:   - archs:           [ arm64 ]
 # CHECK-NEXT:     symbols:         [ __Z3fooi ]
 # CHECK-NEXT: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: arm64-apple-watchos
 ObjectFileFormat: TBD
 Symbols:
-  __Z3fooi: { Type: Func }
+  - { Name: __Z3fooi, Type: Func }
 ...

llvm/test/tools/llvm-ifs/weak-mismatch.ifs

 # RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-size.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-SIZE
 # RUN: not llvm-ifs -action write-ifs -o - %s %S/Inputs/strong-mismatch-type.ifs 2>&1 | FileCheck %s --check-prefixes=CHECK-TYPE
 
 # CHECK-SIZE: error: Interface Stub: Size Mismatch for foobar.
 # CHECK-SIZE-NEXT: Filename:
 # CHECK-SIZE-NEXT: Size Values: 1 2
 
 
 # CHECK-TYPE: error: Interface Stub: Type Mismatch for foobar.
 # CHECK-TYPE-NEXT: Filename:
 # CHECK-TYPE-NEXT: Type Values: Object Func
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  foobar: { Type: Object, Size: 1, Weak: true }
+  - { Name: foobar, Type: Object, Size: 1, Weak: true }
 ...

llvm/test/tools/llvm-ifs/weak.ifs

 # RUN: llvm-ifs -action write-ifs -o - %s | FileCheck %s --check-prefixes=CHECK-IFS
 
-# CHECK-IFS: --- !experimental-ifs-v1
-# CHECK-IFS-NEXT: IfsVersion: 1.0
+# CHECK-IFS: --- !experimental-ifs-v2
+# CHECK-IFS-NEXT: IfsVersion: 2.0
 # CHECK-IFS-NEXT: Triple: x86_64-unknown-linux-gnu
 # CHECK-IFS-NEXT: ObjectFileFormat: ELF
 # CHECK-IFS-NEXT: Symbols:
-# CHECK-IFS-DAG:   _Z8weakFuncv: { Type: Func, Weak: true }
-# CHECK-IFS-DAG:   _Z10strongFuncv: { Type: Func }
+# CHECK-IFS-DAG:   - { Name: _Z8weakFuncv, Type: Func, Weak: true }
+# CHECK-IFS-DAG:   - { Name: _Z10strongFuncv, Type: Func }
 # CHECK-IFS: ...
 
---- !experimental-ifs-v1
-IfsVersion: 1.0
+--- !experimental-ifs-v2
+IfsVersion: 2.0
 Triple: x86_64-unknown-linux-gnu
 ObjectFileFormat: ELF
 Symbols:
-  _Z8weakFuncv: { Type: Func, Weak: true }
-  _Z10strongFuncv: { Type: Func }
+  - { Name: _Z8weakFuncv, Type: Func, Weak: true }
+  - { Name: _Z10strongFuncv, Type: Func }
 ...

llvm/tools/llvm-ifs/llvm-ifs.cpp

 #include "llvm/Support/WithColor.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/TextAPI/MachO/InterfaceFile.h"
 #include "llvm/TextAPI/MachO/TextAPIReader.h"
 #include "llvm/TextAPI/MachO/TextAPIWriter.h"
 #include <set>
 #include <string>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::yaml;
 using namespace llvm::MachO;
 
 #define DEBUG_TYPE "llvm-ifs"
 
 namespace {
-const VersionTuple IFSVersionCurrent(1, 2);
-}
+const VersionTuple IFSVersionCurrent(2, 0);
+} // end anonymous namespace
 
 static cl::opt<std::string> Action("action", cl::desc("<llvm-ifs action>"),
                                    cl::value_desc("write-ifs | write-bin"),
                                    cl::init("write-ifs"));
 
 static cl::opt<std::string> ForceFormat("force-format",
                                         cl::desc("<force object format>"),
                                         cl::value_desc("ELF | TBD"),
case IFSSymbolType::Object:
     return "Object";
   case IFSSymbolType::Unknown:
     return "Unknown";
   }
   llvm_unreachable("Unexpected ifs symbol type.");
 }
 
 struct IFSSymbol {
+  IFSSymbol() = default;
   IFSSymbol(std::string SymbolName) : Name(SymbolName) {}
   std::string Name;
   uint64_t Size;
   IFSSymbolType Type;
   bool Weak;
   Optional<std::string> Warning;
   bool operator<(const IFSSymbol &RHS) const { return Name < RHS.Name; }
 };
 
+LLVM_YAML_IS_SEQUENCE_VECTOR(IFSSymbol)
+
 namespace llvm {
 namespace yaml {
 /// YAML traits for IFSSymbolType.
 template <> struct ScalarEnumerationTraits<IFSSymbolType> {
   static void enumeration(IO &IO, IFSSymbolType &SymbolType) {
     IO.enumCase(SymbolType, "NoType", IFSSymbolType::NoType);
     IO.enumCase(SymbolType, "Func", IFSSymbolType::Func);
     IO.enumCase(SymbolType, "Object", IFSSymbolType::Object);
template <> struct ScalarTraits<VersionTuple> {
 
   // Don't place quotation marks around version value.
   static QuotingType mustQuote(StringRef) { return QuotingType::None; }
 };
 
 /// YAML traits for IFSSymbol.
 template <> struct MappingTraits<IFSSymbol> {
   static void mapping(IO &IO, IFSSymbol &Symbol) {
+    IO.mapRequired("Name", Symbol.Name);
     IO.mapRequired("Type", Symbol.Type);
     // The need for symbol size depends on the symbol type.
     if (Symbol.Type == IFSSymbolType::NoType)
       IO.mapOptional("Size", Symbol.Size, (uint64_t)0);
     else if (Symbol.Type == IFSSymbolType::Func)
       Symbol.Size = 0;
     else
       IO.mapRequired("Size", Symbol.Size);
     IO.mapOptional("Weak", Symbol.Weak, false);
     IO.mapOptional("Warning", Symbol.Warning);
   }
 
   // Compacts symbol information into a single line.
   static const bool flow = true;
 };
 
-/// YAML traits for set of IFSSymbols.
-template <> struct CustomMappingTraits<std::set<IFSSymbol>> {
-  static void inputOne(IO &IO, StringRef Key, std::set<IFSSymbol> &Set) {
-    std::string Name = Key.str();
-    IFSSymbol Sym(Name);
-    IO.mapRequired(Name.c_str(), Sym);
-    Set.insert(Sym);
-  }
-
-  static void output(IO &IO, std::set<IFSSymbol> &Set) {
-    for (auto &Sym : Set)
-      IO.mapRequired(Sym.Name.c_str(), const_cast<IFSSymbol &>(Sym));
-  }
-};
 } // namespace yaml
 } // namespace llvm
 
 // A cumulative representation of ELF stubs.
 // Both textual and binary stubs will read into and write from this object.
 class IFSStub {
   // TODO: Add support for symbol versioning.
 public:
   VersionTuple IfsVersion;
   std::string Triple;
   std::string ObjectFileFormat;
   Optional<std::string> SOName;
   std::vector<std::string> NeededLibs;
-  std::set<IFSSymbol> Symbols;
+  std::vector<IFSSymbol> Symbols;
 
   IFSStub() = default;
   IFSStub(const IFSStub &Stub)
       : IfsVersion(Stub.IfsVersion), Triple(Stub.Triple),
         ObjectFileFormat(Stub.ObjectFileFormat), SOName(Stub.SOName),
         NeededLibs(Stub.NeededLibs), Symbols(Stub.Symbols) {}
   IFSStub(IFSStub &&Stub)
       : IfsVersion(std::move(Stub.IfsVersion)), Triple(std::move(Stub.Triple)),
         ObjectFileFormat(std::move(Stub.ObjectFileFormat)),
         SOName(std::move(Stub.SOName)), NeededLibs(std::move(Stub.NeededLibs)),
         Symbols(std::move(Stub.Symbols)) {}
 };
 
 namespace llvm {
 namespace yaml {
 /// YAML traits for IFSStub objects.
 template <> struct MappingTraits<IFSStub> {
   static void mapping(IO &IO, IFSStub &Stub) {
-    if (!IO.mapTag("!experimental-ifs-v1", true))
+    if (!IO.mapTag("!experimental-ifs-v2", true))
       IO.setError("Not a .ifs YAML file.");
+
+    auto oldContext = IO.getContext();
+    IO.setContext(&Stub);
     IO.mapRequired("IfsVersion", Stub.IfsVersion);
     IO.mapOptional("Triple", Stub.Triple);
     IO.mapOptional("ObjectFileFormat", Stub.ObjectFileFormat);
     IO.mapOptional("SOName", Stub.SOName);
     IO.mapOptional("NeededLibs", Stub.NeededLibs);
     IO.mapRequired("Symbols", Stub.Symbols);
+    IO.setContext(&oldContext);
   }
 };
 } // namespace yaml
 } // namespace llvm
 
 static Expected<std::unique_ptr<IFSStub>> readInputFile(StringRef FilePath) {
   // Read in file.
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrError =
       MemoryBuffer::getFileOrSTDIN(FilePath);
   if (!BufOrError)
     return createStringError(BufOrError.getError(), "Could not open `%s`",
                              FilePath.data());
 
   std::unique_ptr<MemoryBuffer> FileReadBuffer = std::move(*BufOrError);
   yaml::Input YamlIn(FileReadBuffer->getBuffer());
   std::unique_ptr<IFSStub> Stub(new IFSStub());
   YamlIn >> *Stub;
 
   if (std::error_code Err = YamlIn.error())
     return createStringError(Err, "Failed reading Interface Stub File.");
 
   return std::move(Stub);
 }
 
-int writeTbdStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols,
+int writeTbdStub(const llvm::Triple &T, const std::vector<IFSSymbol> &Symbols,
                  const StringRef Format, raw_ostream &Out) {
 
   auto PlatformKindOrError =
       [](const llvm::Triple &T) -> llvm::Expected<llvm::MachO::PlatformKind> {
     if (T.isMacOSX())
       return llvm::MachO::PlatformKind::macOS;
     if (T.isTvOS())
       return llvm::MachO::PlatformKind::tvOS;
int writeTbdStub(const llvm::Triple &T, const std::vector<IFSSymbol> &Symbols,
   SmallString<4096> Buffer;
   raw_svector_ostream OS(Buffer);
   if (Error Result = TextAPIWriter::writeToStream(OS, File))
     return -1;
   Out << OS.str();
   return 0;
 }
 
-int writeElfStub(const llvm::Triple &T, const std::set<IFSSymbol> &Symbols,
+int writeElfStub(const llvm::Triple &T, const std::vector<IFSSymbol> &Symbols,
                  const StringRef Format, raw_ostream &Out) {
   SmallString<0> Storage;
   Storage.clear();
   raw_svector_ostream OS(Storage);
 
   OS << "--- !ELF\n";
   OS << "FileHeader:\n";
   OS << "  Class:           ELFCLASS";
int writeIfso(const IFSStub &Stub, bool IsWriteIfs, raw_ostream &Out) {
 
   WithColor::error()
       << "Invalid ObjectFileFormat: Only ELF and TBD are supported.\n";
   return -1;
 }
 
 // TODO: Drop ObjectFileFormat, it can be subsumed from the triple.
 // New Interface Stubs Yaml Format:
-// --- !experimental-ifs-v1
-// IfsVersion:      1.0
+// --- !experimental-ifs-v2
+// IfsVersion: 2.0
 // Triple:          <llvm triple>
 // ObjectFileFormat: <ELF | others not yet supported>
 // Symbols:
 //   _ZSymbolName: { Type: <type> }
 // ...
 
 int main(int argc, char *argv[]) {
   // Parse arguments.
if (Stub.IfsVersion != IFSVersionCurrent)
     if (Stub.IfsVersion.getMajor() != IFSVersionCurrent.getMajor()) {
       WithColor::error() << "Interface Stub: Bad IfsVersion: "
                          << Stub.IfsVersion << ", llvm-ifs supported version: "
                          << IFSVersionCurrent << ".\n";
       return -1;
     }
 
   for (auto &Entry : SymbolMap)
-    Stub.Symbols.insert(Entry.second);
+    Stub.Symbols.push_back(Entry.second);
 
   std::error_code SysErr;
 
   // Open file for writing.
   raw_fd_ostream Out(OutputFilename, SysErr);
   if (SysErr) {
     WithColor::error() << "Couldn't open " << OutputFilename
                        << " for writing.\n";
     return -1;
   }
 
   return writeIfso(Stub, (Action == "write-ifs"), Out);
 }