Debug Info: Modified DIBuilder::createCompileUnit() to take DIFile instead of FileName and Directory. (LLVM part)

[aaboud]

Summary

Changed DIBuilder::createCompileUnit() to take DIFile instead of FileName and Directory.
This way it will be easier to expand DIFile (e.g., to contain checksum) without the need to modify the createCompileUnit() API.

[rnk]

Thanks!

[pcc]

This broke the Go bindings tests, can you please take a look?

[aaboud]

In D27762#624190, @pcc wrote:

This broke the Go bindings tests, can you please take a look?

It seems djasper already fixed it few hours ago:

Fix go bindings after r289702 (hopefully, don't really know how to build
them, build.sh seems to be broken).

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@289775 91177308-0d34-0410-b5e6-96231b3b80d8

[pcc]

You're right, sorry for the noise. But it looks like D27642 will have the same problem.

[aaboud]

In D27762#624265, @pcc wrote:

You're right, sorry for the noise. But it looks like D27642 will have the same problem.

Hopefully now, as I am adding a default values for the extra parameters for DIFile creation.
But I will double check that before committing.

Thanks for pointing this out.

llvm/trunk/include/llvm/IR/DIBuilder.h

public:
     DIBuilder &operator=(const DIBuilder &) = delete;
 
     /// Construct any deferred debug info descriptors.
     void finalize();
 
     /// A CompileUnit provides an anchor for all debugging
     /// information generated during this instance of compilation.
     /// \param Lang          Source programming language, eg. dwarf::DW_LANG_C99
-    /// \param File          File name
-    /// \param Dir           Directory
+    /// \param File          File info.
     /// \param Producer      Identify the producer of debugging information
     ///                      and code.  Usually this is a compiler
     ///                      version string.
     /// \param isOptimized   A boolean flag which indicates whether optimization
     ///                      is enabled or not.
     /// \param Flags         This string lists command line options. This
     ///                      string is directly embedded in debug info
     ///                      output which may be used by a tool
     ///                      analyzing generated debugging information.
     /// \param RV            This indicates runtime version for languages like
     ///                      Objective-C.
     /// \param SplitName     The name of the file that we'll split debug info
     ///                      out into.
     /// \param Kind          The kind of debug information to generate.
     /// \param DWOId         The DWOId if this is a split skeleton compile unit.
     DICompileUnit *
-    createCompileUnit(unsigned Lang, StringRef File, StringRef Dir,
-                      StringRef Producer, bool isOptimized, StringRef Flags,
-                      unsigned RV, StringRef SplitName = StringRef(),
+    createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer,
+                      bool isOptimized, StringRef Flags, unsigned RV,
+                      StringRef SplitName = StringRef(),
                       DICompileUnit::DebugEmissionKind Kind =
                           DICompileUnit::DebugEmissionKind::FullDebug,
                       uint64_t DWOId = 0, bool SplitDebugInlining = true);
 
     /// Create a file descriptor to hold debugging information
     /// for a file.
     DIFile *createFile(StringRef Filename, StringRef Directory);
 

llvm/trunk/lib/IR/DIBuilder.cpp

 /// If N is compile unit return NULL otherwise return N.
 static DIScope *getNonCompileUnitScope(DIScope *N) {
   if (!N || isa<DICompileUnit>(N))
     return nullptr;
   return cast<DIScope>(N);
 }
 
 DICompileUnit *DIBuilder::createCompileUnit(
-    unsigned Lang, StringRef Filename, StringRef Directory, StringRef Producer,
-    bool isOptimized, StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
+    unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized,
+    StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
     DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
     bool SplitDebugInlining) {
 
   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
-  assert(!Filename.empty() &&
-         "Unable to create compile unit without filename");
 
   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
   CUNode = DICompileUnit::getDistinct(
-      VMContext, Lang, DIFile::get(VMContext, Filename, Directory), Producer,
-      isOptimized, Flags, RunTimeVer, SplitName, Kind, nullptr, nullptr,
-      nullptr, nullptr, nullptr, DWOId, SplitDebugInlining);
+      VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
+      SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId,
+      SplitDebugInlining);
 
   // Create a named metadata so that it is easier to find cu in a module.
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(CUNode);
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 

llvm/trunk/unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, RAIIHelpersTest) {
   EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
   EXPECT_EQ(BB, Builder.GetInsertBlock());
 }
 
 TEST_F(IRBuilderTest, DIBuilder) {
   IRBuilder<> Builder(BB);
   DIBuilder DIB(*M);
   auto File = DIB.createFile("F.CBL", "/");
-  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74, "F.CBL", "/",
-                                  "llvm-cobol74", true, "", 0);
+  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
+                                  DIB.createFile("F.CBL", "/"), "llvm-cobol74",
+                                  true, "", 0);
   auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
   auto SP = DIB.createFunction(CU, "foo", "", File, 1, Type, false, true, 1,
                                DINode::FlagZero, true);
   F->setSubprogram(SP);
   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
   auto BarSP = DIB.createFunction(CU, "bar", "", File, 1, Type, false, true, 1,
                                   DINode::FlagZero, true);
   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);

 TEST_F(IRBuilderTest, DebugLoc) {
   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
                                     /*isVarArg=*/false);
   auto Callee =
       Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
 
   DIBuilder DIB(*M);
   auto File = DIB.createFile("tmp.cpp", "/");
-  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11, "tmp.cpp", "/",
-                                  "", true, "", 0);
+  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
+                                  DIB.createFile("tmp.cpp", "/"), "", true, "",
+                                  0);
   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
   auto SP =
       DIB.createFunction(CU, "foo", "foo", File, 1, SPType, false, true, 1);
   DebugLoc DL1 = DILocation::get(Ctx, 2, 0, SP);
   DebugLoc DL2 = DILocation::get(Ctx, 3, 0, SP);
 
   auto BB2 = BasicBlock::Create(Ctx, "bb2", F);
   auto Br = BranchInst::Create(BB2, BB);
TEST_F(IRBuilderTest, DebugLoc) {
   EXPECT_EQ(DL2, Call2->getDebugLoc());
 
   DIB.finalize();
 }
 
 TEST_F(IRBuilderTest, DIImportedEntity) {
   IRBuilder<> Builder(BB);
   DIBuilder DIB(*M);
-  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74, "F.CBL", "/",
-    "llvm-cobol74", true, "", 0);
+  auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
+                                  DIB.createFile("F.CBL", "/"), "llvm-cobol74",
+                                  true, "", 0);
   DIB.createImportedDeclaration(CU, nullptr, 1);
   DIB.createImportedDeclaration(CU, nullptr, 1);
   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, 2);
   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, 2);
   DIB.finalize();
   EXPECT_TRUE(verifyModule(*M));
   EXPECT_TRUE(CU->getImportedEntities().size() == 2);
 }
 }

llvm/trunk/unittests/IR/VerifierTest.cpp

EXPECT_TRUE(
                                           "have external or weak linkage!"));
 }
 
 TEST(VerifierTest, StripInvalidDebugInfo) {
   {
     LLVMContext C;
     Module M("M", C);
     DIBuilder DIB(M);
-    DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/", "unittest",
-                          false, "", 0);
+    DIB.createCompileUnit(dwarf::DW_LANG_C89, DIB.createFile("broken.c", "/"),
+                          "unittest", false, "", 0);
     DIB.finalize();
     EXPECT_FALSE(verifyModule(M));
 
     // Now break it by inserting non-CU node to the list of CUs.
     auto *File = DIB.createFile("not-a-CU.f", ".");
     NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
     NMD->addOperand(File);
     EXPECT_TRUE(verifyModule(M));
 
     ModulePassManager MPM(true);
     MPM.addPass(VerifierPass(false));
     ModuleAnalysisManager MAM(true);
     MAM.registerPass([&] { return VerifierAnalysis(); });
     MPM.run(M, MAM);
     EXPECT_FALSE(verifyModule(M));
   }
   {
     LLVMContext C;
     Module M("M", C);
     DIBuilder DIB(M);
-    auto *CU = DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/",
+    auto *CU = DIB.createCompileUnit(dwarf::DW_LANG_C89,
+                                     DIB.createFile("broken.c", "/"),
                                      "unittest", false, "", 0);
     new GlobalVariable(M, Type::getInt8Ty(C), false,
                        GlobalValue::ExternalLinkage, nullptr, "g");
 
     auto *F = cast<Function>(M.getOrInsertFunction(
         "f", FunctionType::get(Type::getVoidTy(C), false)));
     IRBuilder<> Builder(BasicBlock::Create(C, "", F));
     Builder.CreateUnreachable();
TEST(VerifierTest, StripInvalidDebugInfo) {
     EXPECT_FALSE(verifyModule(M));
   }
 }
 
 TEST(VerifierTest, StripInvalidDebugInfoLegacy) {
   LLVMContext C;
   Module M("M", C);
   DIBuilder DIB(M);
-  DIB.createCompileUnit(dwarf::DW_LANG_C89, "broken.c", "/",
+  DIB.createCompileUnit(dwarf::DW_LANG_C89, DIB.createFile("broken.c", "/"),
                         "unittest", false, "", 0);
   DIB.finalize();
   EXPECT_FALSE(verifyModule(M));
 
   // Now break it.
   auto *File = DIB.createFile("not-a-CU.f", ".");
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(File);

llvm/trunk/unittests/Transforms/Utils/Cloning.cpp

void CreateOldFunctionBodyAndDI() {
     DIBuilder DBuilder(*M);
     IRBuilder<> IBuilder(C);
 
     // Function DI
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
     DISubroutineType *FuncType =
         DBuilder.createSubroutineType(ParamTypes);
-    auto *CU =
-        DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
-                                   "/file/dir", "CloneFunc", false, "", 0);
+    auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
+                                          DBuilder.createFile("filename.c",
+                                                              "/file/dir"),
+                                          "CloneFunc", false, "", 0);
 
     auto *Subprogram =
         DBuilder.createFunction(CU, "f", "f", File, 4, FuncType, true, true, 3,
                                 DINode::FlagZero, false);
     OldFunc->setSubprogram(Subprogram);
 
     // Function body
     BasicBlock* Entry = BasicBlock::Create(C, "", OldFunc);
DBuilder.insertDbgValueIntrinsic(AllocaContent, 0, Variable, E, DL,
                                      Terminator);
     // Finalize the debug info
     DBuilder.finalize();
 
 
     // Create another, empty, compile unit
     DIBuilder DBuilder2(*M);
     DBuilder2.createCompileUnit(dwarf::DW_LANG_C99,
-        "extra.c", "/file/dir", "CloneFunc", false, "", 0);
+                                DBuilder.createFile("extra.c", "/file/dir"),
+                                "CloneFunc", false, "", 0);
     DBuilder2.finalize();
   }
 
   void CreateNewFunc() {
     ValueToValueMapTy VMap;
     NewFunc = CloneFunction(OldFunc, VMap, nullptr);
   }
 
void CreateOldModule() {
     auto *F =
         Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
     F->setPersonalityFn(PersFn);
 
     // Create debug info
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
     DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
-    auto *CU =
-        DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
-                                   "/file/dir", "CloneModule", false, "", 0);
+    auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,
+                                          DBuilder.createFile("filename.c",
+                                                              "/file/dir"),
+                                          "CloneModule", false, "", 0);
     // Function DI
     auto *Subprogram =
         DBuilder.createFunction(CU, "f", "f", File, 4, DFuncType, true, true, 3,
                                 DINode::FlagZero, false);
     F->setSubprogram(Subprogram);
 
     auto *Entry = BasicBlock::Create(C, "", F);
     IBuilder.SetInsertPoint(Entry);