[clang][IFS] Adding new Interface Stubs format.

[plotfi]

Summary

After posting llvm-ifs, I made some progress in hardening up how I think the format for Interface Stubs should look.
There are a number of things I think the TBE format was missing (no endianness, no info about the Object Format because it assumes ELF), so I have added those and broken off from being as similar to the TBE schema. I think in a subsequent commit I can drop the other formats.

[plotfi]

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

363 ↗

(On Diff #216001)

This is missing ObjectFileFormat: ELF

[plotfi]

Adding ObjectFileFormat

[compnerd]

Please add a test case for read/write, otherwise LGTM.

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

383 ↗

(On Diff #216004)

Why is this comma separated rather than a separate value?

392 ↗

(On Diff #216004)

Why comma separated rather than new KV pair?

[plotfi]

clang/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

383 ↗

(On Diff #216004)

Vestiges of TBE elfabi inspiration. It can change in experimental-ifs-v2 / 1.1 or something.

392 ↗

(On Diff #216004)

Vestiges of TBE elfabi inspiration. It can change in experimental-ifs-v2 / 1.1 or something.

cfe/trunk/include/clang/Frontend/FrontendActions.h

 };
 
 class GenerateInterfaceTBEExpV1Action : public GenerateInterfaceStubAction {
 protected:
   std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
                                                  StringRef InFile) override;
 };
 
+class GenerateInterfaceIfsExpV1Action : public GenerateInterfaceStubAction {
+protected:
+  std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
+                                                 StringRef InFile) override;
+};
+
 class GenerateModuleFromModuleMapAction : public GenerateModuleAction {
 private:
   bool BeginSourceFileAction(CompilerInstance &CI) override;
 
   std::unique_ptr<raw_pwrite_stream>
   CreateOutputFile(CompilerInstance &CI, StringRef InFile) override;
 };
 

cfe/trunk/include/clang/Frontend/FrontendOptions.h

enum ActionKind {
   GenerateHeaderModule,
 
   /// Generate pre-compiled header.
   GeneratePCH,
 
   /// Generate Interface Stub Files.
   GenerateInterfaceYAMLExpV1,
   GenerateInterfaceTBEExpV1,
+  GenerateInterfaceIfsExpV1,
 
   /// Only execute frontend initialization.
   InitOnly,
 
   /// Dump information about a module file.
   ModuleFileInfo,
 
   /// Load and verify that a PCH file is usable.

cfe/trunk/lib/Driver/ToolChains/Clang.cpp

if (isa<AnalyzeJobAction>(JA)) {
     } else if (JA.getType() == types::TY_IFS) {
       StringRef StubFormat =
           llvm::StringSwitch<StringRef>(
               Args.hasArg(options::OPT_iterface_stub_version_EQ)
                   ? Args.getLastArgValue(options::OPT_iterface_stub_version_EQ)
                   : "")
               .Case("experimental-yaml-elf-v1", "experimental-yaml-elf-v1")
               .Case("experimental-tapi-elf-v1", "experimental-tapi-elf-v1")
+              .Case("experimental-ifs-v1", "experimental-ifs-v1")
               .Default("");
 
       if (StubFormat.empty())
         D.Diag(diag::err_drv_invalid_value)
             << "Must specify a valid interface stub format type using "
             << "-interface-stub-version=<experimental-tapi-elf-v1 | "
+               "experimental-ifs-v1 | "
                "experimental-yaml-elf-v1>";
 
       CmdArgs.push_back("-emit-interface-stubs");
       CmdArgs.push_back(
           Args.MakeArgString(Twine("-interface-stub-version=") + StubFormat));
     } else if (JA.getType() == types::TY_PP_Asm) {
       CmdArgs.push_back("-S");
     } else if (JA.getType() == types::TY_AST) {

cfe/trunk/lib/Frontend/CompilerInvocation.cpp

case OPT_emit_iterface_stubs: {
           llvm::StringSwitch<llvm::Optional<frontend::ActionKind>>(
               Args.hasArg(OPT_iterface_stub_version_EQ)
                   ? Args.getLastArgValue(OPT_iterface_stub_version_EQ)
                   : "")
               .Case("experimental-yaml-elf-v1",
                     frontend::GenerateInterfaceYAMLExpV1)
               .Case("experimental-tapi-elf-v1",
                     frontend::GenerateInterfaceTBEExpV1)
+              .Case("experimental-ifs-v1",
+                    frontend::GenerateInterfaceIfsExpV1)
               .Default(llvm::None);
       if (!ProgramAction)
         Diags.Report(diag::err_drv_invalid_value)
             << "Must specify a valid interface stub format type using "
             << "-interface-stub-version=<experimental-tapi-elf-v1 | "
+               "experimental-ifs-v1 | "
                "experimental-yaml-elf-v1>";
       Opts.ProgramAction = *ProgramAction;
       break;
     }
     case OPT_init_only:
       Opts.ProgramAction = frontend::InitOnly; break;
     case OPT_fsyntax_only:
       Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
   case frontend::EmitObj:
   case frontend::FixIt:
   case frontend::GenerateModule:
   case frontend::GenerateModuleInterface:
   case frontend::GenerateHeaderModule:
   case frontend::GeneratePCH:
   case frontend::GenerateInterfaceYAMLExpV1:
   case frontend::GenerateInterfaceTBEExpV1:
+  case frontend::GenerateInterfaceIfsExpV1:
   case frontend::ParseSyntaxOnly:
   case frontend::ModuleFileInfo:
   case frontend::VerifyPCH:
   case frontend::PluginAction:
   case frontend::RewriteObjC:
   case frontend::RewriteTest:
   case frontend::RunAnalysis:
   case frontend::TemplightDump:

cfe/trunk/lib/Frontend/InterfaceStubFunctionsConsumer.cpp

auto writeIfoElfAbiYaml =
             OS << ", Weak: true";
           OS << " }\n";
         }
       }
       OS << "...\n";
       OS.flush();
     };
 
+    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 << "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 << "  "
+             << (Symbol.ParentName.empty() || Instance.getLangOpts().CPlusPlus
+                     ? ""
+                     : (Symbol.ParentName + "."))
+             << Name << ": { Type: ";
+          switch (Symbol.Type) {
+          default:
+            llvm_unreachable(
+                "clang -emit-iterface-stubs: Unexpected symbol type.");
+          case llvm::ELF::STT_NOTYPE:
+            OS << "NoType";
+            break;
+          case llvm::ELF::STT_OBJECT: {
+            auto VD = cast<ValueDecl>(E.first)->getType();
+            OS << "Object, Size: "
+               << context.getTypeSizeInChars(VD).getQuantity();
+            break;
+          }
+          case llvm::ELF::STT_FUNC:
+            OS << "Func";
+            break;
+          }
+          if (Symbol.Binding == llvm::ELF::STB_WEAK)
+            OS << ", Weak: true";
+          OS << " }\n";
+        }
+      }
+      OS << "...\n";
+      OS.flush();
+    };
+
     if (Format == "experimental-yaml-elf-v1")
       writeIfoYaml(Instance.getTarget().getTriple(), Symbols, context, Format,
                    *OS);
+    else if (Format == "experimental-ifs-v1")
+      writeIfsV1(Instance.getTarget().getTriple(), Symbols, context, Format,
+                 *OS);
     else
       writeIfoElfAbiYaml(Instance.getTarget().getTriple(), Symbols, context,
                          Format, *OS);
   }
 };
 
 std::unique_ptr<ASTConsumer>
 GenerateInterfaceYAMLExpV1Action::CreateASTConsumer(CompilerInstance &CI,
                                                     StringRef InFile) {
   return std::make_unique<InterfaceStubFunctionsConsumer>(
       CI, InFile, "experimental-yaml-elf-v1");
 }
 
 std::unique_ptr<ASTConsumer>
 GenerateInterfaceTBEExpV1Action::CreateASTConsumer(CompilerInstance &CI,
                                                    StringRef InFile) {
   return std::make_unique<InterfaceStubFunctionsConsumer>(
       CI, InFile, "experimental-tapi-elf-v1");
 }
+
+std::unique_ptr<ASTConsumer>
+GenerateInterfaceIfsExpV1Action::CreateASTConsumer(CompilerInstance &CI,
+                                                   StringRef InFile) {
+  return std::make_unique<InterfaceStubFunctionsConsumer>(
+      CI, InFile, "experimental-ifs-v1");
+}

cfe/trunk/lib/FrontendTool/ExecuteCompilerInvocation.cpp

case GenerateModuleInterface:
     return std::make_unique<GenerateModuleInterfaceAction>();
   case GenerateHeaderModule:
     return std::make_unique<GenerateHeaderModuleAction>();
   case GeneratePCH:            return std::make_unique<GeneratePCHAction>();
   case GenerateInterfaceYAMLExpV1:
     return std::make_unique<GenerateInterfaceYAMLExpV1Action>();
   case GenerateInterfaceTBEExpV1:
     return std::make_unique<GenerateInterfaceTBEExpV1Action>();
+  case GenerateInterfaceIfsExpV1:
+    return std::make_unique<GenerateInterfaceIfsExpV1Action>();
   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 =