Add -fcas-emit-casid-file to emit a .casid file

rastogishubham · rastogishubham · commit 142e1b1827cd · 2023-08-23T14:14:38.000-07:00
With -fcas-emit-casid-file, a .casid file will be emitted next to the
object file only when -fcas-backend-mode=native, or
-fcas-backend-mode=verify is used and the output is directed to a file,
rather than stdout.
diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def
@@ -516,6 +516,9 @@ ENUM_CODEGENOPT(ZeroCallUsedRegs, llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind,
 /// Whether to use CASID backend.
 CODEGENOPT(UseCASBackend, 1, 0)
 
+/// Whether to emit a .casid File.
+CODEGENOPT(EmitCASIDFile, 1, 0)
+
 /// The CASObjectFormat used when CAS output is used.
 ENUM_CODEGENOPT(CASObjMode, llvm::CASBackendMode,
                 2, llvm::CASBackendMode::Native)
diff --git a/clang/include/clang/CodeGen/BackendUtil.h b/clang/include/clang/CodeGen/BackendUtil.h
@@ -48,7 +48,8 @@ namespace clang {
                          const CASOptions &CASOpts, // MCCAS
                          StringRef TDesc, llvm::Module *M, BackendAction Action,
                          llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-                         std::unique_ptr<raw_pwrite_stream> OS);
+                         std::unique_ptr<raw_pwrite_stream> OS,
+                         std::unique_ptr<raw_pwrite_stream> CasidOS = nullptr);
 
   void EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
                     llvm::MemoryBufferRef Buf);
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
@@ -7855,6 +7855,11 @@ defm cas_backend : BoolFOption<"cas-backend",
     PosFlag<SetTrue, [], [ClangOption], "Enable using CASBackend for object file output">,
     NegFlag<SetFalse>>;
 
+defm cas_emit_casid_file : BoolFOption<"cas-emit-casid-file",
+    CodeGenOpts<"EmitCASIDFile">, DefaultFalse,
+    PosFlag<SetTrue, [], [], "Emit .casid file next to object file when using cas backend">,
+    NegFlag<SetFalse>>;
+
 def fcas_backend_mode : Joined<["-"], "fcas-backend-mode=">,
     Group<f_Group>, MetaVarName<"<native|casid|verify>">,
     HelpText<"CASBackendMode for output kind">,
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
@@ -144,7 +144,8 @@ class EmitAssemblyHelper {
   ///
   /// \return True on success.
   bool AddEmitPasses(legacy::PassManager &CodeGenPasses, BackendAction Action,
-                     raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS);
+                     raw_pwrite_stream &OS, raw_pwrite_stream *DwoOS,
+                     raw_pwrite_stream *CasIDOS = nullptr);
 
   std::unique_ptr<llvm::ToolOutputFile> openOutputFile(StringRef Path) {
     std::error_code EC;
@@ -163,7 +164,8 @@ class EmitAssemblyHelper {
                           std::unique_ptr<llvm::ToolOutputFile> &ThinLinkOS);
   void RunCodegenPipeline(BackendAction Action,
                           std::unique_ptr<raw_pwrite_stream> &OS,
-                          std::unique_ptr<llvm::ToolOutputFile> &DwoOS);
+                          std::unique_ptr<llvm::ToolOutputFile> &DwoOS,
+                          std::unique_ptr<raw_pwrite_stream> &CasIDOS);
 
   /// Check whether we should emit a module summary for regular LTO.
   /// The module summary should be emitted by default for regular LTO
@@ -198,8 +200,8 @@ class EmitAssemblyHelper {
   std::unique_ptr<TargetMachine> TM;
 
   // Emit output using the new pass manager for the optimization pipeline.
-  void EmitAssembly(BackendAction Action,
-                    std::unique_ptr<raw_pwrite_stream> OS);
+  void EmitAssembly(BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
+                    std::unique_ptr<raw_pwrite_stream> CasIDOS = nullptr);
 };
 }
 
@@ -590,7 +592,8 @@ void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
                                        BackendAction Action,
                                        raw_pwrite_stream &OS,
-                                       raw_pwrite_stream *DwoOS) {
+                                       raw_pwrite_stream *DwoOS,
+                                       raw_pwrite_stream *CasIDOS) {
   // Add LibraryInfo.
   std::unique_ptr<TargetLibraryInfoImpl> TLII(
       createTLII(TargetTriple, CodeGenOpts));
@@ -607,7 +610,8 @@ bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
     CodeGenPasses.add(createObjCARCContractPass());
 
   if (TM->addPassesToEmitFile(CodeGenPasses, OS, DwoOS, CGFT,
-                              /*DisableVerify=*/!CodeGenOpts.VerifyModule)) {
+                              /*DisableVerify=*/!CodeGenOpts.VerifyModule,
+                              nullptr, CasIDOS)) {
     Diags.Report(diag::err_fe_unable_to_interface_with_target);
     return false;
   }
@@ -1127,7 +1131,8 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
 
 void EmitAssemblyHelper::RunCodegenPipeline(
     BackendAction Action, std::unique_ptr<raw_pwrite_stream> &OS,
-    std::unique_ptr<llvm::ToolOutputFile> &DwoOS) {
+    std::unique_ptr<llvm::ToolOutputFile> &DwoOS,
+    std::unique_ptr<raw_pwrite_stream> &CasIDOS) {
   // We still use the legacy PM to run the codegen pipeline since the new PM
   // does not work with the codegen pipeline.
   // FIXME: make the new PM work with the codegen pipeline.
@@ -1146,7 +1151,7 @@ void EmitAssemblyHelper::RunCodegenPipeline(
         return;
     }
     if (!AddEmitPasses(CodeGenPasses, Action, *OS,
-                       DwoOS ? &DwoOS->os() : nullptr))
+                       DwoOS ? &DwoOS->os() : nullptr, CasIDOS.get()))
       // FIXME: Should we handle this error differently?
       return;
     break;
@@ -1161,8 +1166,9 @@ void EmitAssemblyHelper::RunCodegenPipeline(
   }
 }
 
-void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
-                                      std::unique_ptr<raw_pwrite_stream> OS) {
+void EmitAssemblyHelper::EmitAssembly(
+    BackendAction Action, std::unique_ptr<raw_pwrite_stream> OS,
+    std::unique_ptr<raw_pwrite_stream> CasIDOS) {
   TimeRegion Region(CodeGenOpts.TimePasses ? &CodeGenerationTime : nullptr);
   setCommandLineOpts(CodeGenOpts);
 
@@ -1179,7 +1185,7 @@ void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
 
   std::unique_ptr<llvm::ToolOutputFile> ThinLinkOS, DwoOS;
   RunOptimizationPipeline(Action, OS, ThinLinkOS);
-  RunCodegenPipeline(Action, OS, DwoOS);
+  RunCodegenPipeline(Action, OS, DwoOS, CasIDOS);
 
   if (ThinLinkOS)
     ThinLinkOS->keep();
@@ -1302,7 +1308,8 @@ void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
                               const CASOptions &CASOpts, // MCCAS
                               StringRef TDesc, Module *M, BackendAction Action,
                               IntrusiveRefCntPtr<llvm::vfs::FileSystem> VFS,
-                              std::unique_ptr<raw_pwrite_stream> OS) {
+                              std::unique_ptr<raw_pwrite_stream> OS,
+                              std::unique_ptr<raw_pwrite_stream> CasIDOS) {
 
   llvm::TimeTraceScope TimeScope("Backend");
 
@@ -1348,7 +1355,7 @@ void clang::EmitBackendOutput(DiagnosticsEngine &Diags,
   EmitAssemblyHelper AsmHelper(Diags, HeaderOpts, CGOpts, TOpts, LOpts,
                                CASOpts, // MCCAS
                                M, VFS);
-  AsmHelper.EmitAssembly(Action, std::move(OS));
+  AsmHelper.EmitAssembly(Action, std::move(OS), std::move(CasIDOS));
 
   // Verify clang's TargetInfo DataLayout against the LLVM TargetMachine's
   // DataLayout.
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -116,6 +116,7 @@ namespace clang {
     const LangOptions &LangOpts;
     const CASOptions &CASOpts; // MCCAS
     std::unique_ptr<raw_pwrite_stream> AsmOutStream;
+    std::unique_ptr<raw_pwrite_stream> CasIDStream;
     ASTContext *Context;
     IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS;
 
@@ -160,11 +161,13 @@ namespace clang {
                     const std::string &InFile,
                     SmallVector<LinkModule, 4> LinkModules,
                     std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
-                    CoverageSourceInfo *CoverageInfo = nullptr)
+                    CoverageSourceInfo *CoverageInfo = nullptr,
+                    std::unique_ptr<raw_pwrite_stream> CasIDOS = nullptr)
         : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
           CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
           CASOpts(CASOpts), // MCCAS
-          AsmOutStream(std::move(OS)), Context(nullptr), FS(VFS),
+          AsmOutStream(std::move(OS)), CasIDStream(std::move(CasIDOS)),
+          Context(nullptr), FS(VFS),
           LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
           LLVMIRGenerationRefCount(0),
           Gen(CreateLLVMCodeGen(Diags, InFile, std::move(VFS), HeaderSearchOpts,
@@ -393,7 +396,8 @@ namespace clang {
       EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
                         LangOpts, CASOpts, // MCCAS
                         C.getTargetInfo().getDataLayoutString(), getModule(),
-                        Action, FS, std::move(AsmOutStream));
+                        Action, FS, std::move(AsmOutStream),
+                        std::move(CasIDStream));
 
       Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));
 
@@ -1079,8 +1083,20 @@ std::unique_ptr<ASTConsumer>
 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   BackendAction BA = static_cast<BackendAction>(Act);
   std::unique_ptr<raw_pwrite_stream> OS = CI.takeOutputStream();
-  if (!OS)
+  std::unique_ptr<raw_pwrite_stream> CasIDOS = nullptr;
+  if (!OS) {
     OS = GetOutputStream(CI, InFile, BA);
+    auto OutputFile = StringRef(CI.getFrontendOpts().OutputFile);
+    if (CI.getCodeGenOpts().UseCASBackend &&
+        CI.getCodeGenOpts().EmitCASIDFile &&
+        CI.getCodeGenOpts().getCASObjMode() != llvm::CASBackendMode::CASID &&
+        BA == Backend_EmitObj && OutputFile != "-") {
+      std::string OutputPathCASIDFile = std::string(OutputFile);
+      OutputPathCASIDFile.append(".casid");
+      CasIDOS = CI.createOutputFile(OutputPathCASIDFile, true, true,
+                                    CI.getFrontendOpts().UseTemporary, false);
+    }
+  }
 
   if (BA != Backend_EmitNothing && !OS)
     return nullptr;
@@ -1101,7 +1117,8 @@ CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
       CI.getTargetOpts(), CI.getLangOpts(),
       CI.getCASOpts(), // MCCAS
       std::string(InFile), std::move(LinkModules), std::move(OS), *VMContext,
-      CoverageInfo));
+      CoverageInfo, std::move(CasIDOS)));
+
   BEConsumer = Result.get();
 
   // Enable generating macro debug info only when debug info is not disabled and
