Remove File from createSubroutineType

[deadalnix]

Summary

It is not used. I kept the old functiona round for backward compatibility, so we have a window to migrate code.

[echristo]

Do you have a patch handy for the migration for clang? I would normally just commit the two back to back to avoid any deprecation period.

(I will do the commit if you need at the end though.)

-eric

[deadalnix]

@echristo yes I have a patch for clang. I can diff it out today if you want.

[echristo]

In D13683#267139, @deadalnix wrote:

@echristo yes I have a patch for clang. I can diff it out today if you want.

That would be great, thanks.

-eric

[deadalnix]

Here you go : D13744

[echristo]

Done in r250374. We both missed the examples directory :)

Thanks for the patch!

-eric

bindings/go/llvm/DIBuilderBindings.cpp

return wrap(D->createPointerType(unwrap<DIType>(PointeeType), SizeInBits,
                                    AlignInBits, Name));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateSubroutineType(LLVMDIBuilderRef Dref, LLVMMetadataRef File,
                                   LLVMMetadataRef ParameterTypes) {
   DIBuilder *D = unwrap(Dref);
   return wrap(
-      D->createSubroutineType(File ? unwrap<DIFile>(File) : nullptr,
-                              DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
+      D->createSubroutineType(DITypeRefArray(unwrap<MDTuple>(ParameterTypes))));
 }
 
 LLVMMetadataRef LLVMDIBuilderCreateStructType(
     LLVMDIBuilderRef Dref, LLVMMetadataRef Scope, const char *Name,
     LLVMMetadataRef File, unsigned Line, uint64_t SizeInBits,
     uint64_t AlignInBits, unsigned Flags, LLVMMetadataRef DerivedFrom,
     LLVMMetadataRef ElementTypes) {
   DIBuilder *D = unwrap(Dref);

include/llvm/IR/DIBuilder.h

public:
     /// \param Elements       Enumeration elements.
     /// \param UnderlyingType Underlying type of a C++11/ObjC fixed enum.
     /// \param UniqueIdentifier A unique identifier for the enum.
     DICompositeType *createEnumerationType(
         DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
         uint64_t SizeInBits, uint64_t AlignInBits, DINodeArray Elements,
         DIType *UnderlyingType, StringRef UniqueIdentifier = "");
 
-    /// Create subroutine type.
+    /// Create subroutine type. This method is DEPRECATED and will be removed.
     /// \param File            File in which this subroutine is defined.
     /// \param ParameterTypes  An array of subroutine parameter types. This
     ///                        includes return type at 0th index.
     /// \param Flags           E.g.: LValueReference.
     ///                        These flags are used to emit dwarf attributes.
     DISubroutineType *createSubroutineType(DIFile *File,
                                            DITypeRefArray ParameterTypes,
                                            unsigned Flags = 0);
 
+    /// Create subroutine type.
+    /// \param ParameterTypes  An array of subroutine parameter types. This
+    ///                        includes return type at 0th index.
+    /// \param Flags           E.g.: LValueReference.
+    ///                        These flags are used to emit dwarf attributes.
+    DISubroutineType *createSubroutineType(DITypeRefArray ParameterTypes,
+                                           unsigned Flags = 0);
+
     /// Create an external type reference.
     /// \param Tag              Dwarf TAG.
     /// \param File             File in which the type is defined.
     /// \param UniqueIdentifier A unique identifier for the type.
     DICompositeType *createExternalTypeRef(unsigned Tag, DIFile *File,
                                            StringRef UniqueIdentifier);
 
     /// Create a new DIType* with "artificial" flag set.
void replaceVTableHolder(DICompositeType *&T,
                              DICompositeType *VTableHolder);
 
     /// Replace arrays on a composite type.
     ///
     /// If \c T is resolved, but the arrays aren't -- which can happen if \c T
     /// has a self-reference -- \a DIBuilder needs to track the array to
     /// resolve cycles.
     void replaceArrays(DICompositeType *&T, DINodeArray Elements,
-                       DINodeArray TParems = DINodeArray());
+                       DINodeArray TParams = DINodeArray());
 
     /// Replace a temporary node.
     ///
     /// Call \a MDNode::replaceAllUsesWith() on \c N, replacing it with \c
     /// Replacement.
     ///
     /// If \c Replacement is the same as \c N.get(), instead call \a
     /// MDNode::replaceWithUniqued().  In this case, the uniqued node could

lib/IR/DIBuilder.cpp

if (!UniqueIdentifier.empty())
     retainType(R);
   trackIfUnresolved(R);
   return R;
 }
 
 DISubroutineType *DIBuilder::createSubroutineType(DIFile *File,
                                                   DITypeRefArray ParameterTypes,
                                                   unsigned Flags) {
+  return this->createSubroutineType(ParameterTypes, Flags);
+}
+
+DISubroutineType *DIBuilder::createSubroutineType(DITypeRefArray ParameterTypes,
+                                                  unsigned Flags) {
   return DISubroutineType::get(VMContext, Flags, ParameterTypes);
 }
 
 DICompositeType *DIBuilder::createExternalTypeRef(unsigned Tag, DIFile *File,
                                                   StringRef UniqueIdentifier) {
   assert(!UniqueIdentifier.empty() && "external type ref without uid");
   auto *CTy =
       DICompositeType::get(VMContext, Tag, "", nullptr, 0, nullptr, nullptr, 0,

unittests/IR/IRBuilderTest.cpp

 }
 
 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 Type = DIB.createSubroutineType(File, DIB.getOrCreateTypeArray(None));
+  auto Type = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
   DIB.createFunction(CU, "foo", "", File, 1, Type, false, true, 1, 0, true, F);
   AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
   auto BarSP = DIB.createFunction(CU, "bar", "", File, 1, Type, false, true, 1,
                                   0, true, nullptr);
   auto BadScope = DIB.createLexicalBlockFile(BarSP, File, 0);
   I->setDebugLoc(DebugLoc::get(2, 0, BadScope));
   DIB.finalize();
   EXPECT_TRUE(verifyModule(*M));
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 SPType = DIB.createSubroutineType(File, DIB.getOrCreateTypeArray(None));
+  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);
   Br->setDebugLoc(DL1);

unittests/Transforms/Utils/Cloning.cpp

protected:
   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(File, ParamTypes);
+        DBuilder.createSubroutineType(ParamTypes);
     auto *CU =
         DBuilder.createCompileUnit(dwarf::DW_LANG_C99, "filename.c",
                                    "/file/dir", "CloneFunc", false, "", 0);
 
     auto *Subprogram = DBuilder.createFunction(
         CU, "f", "f", File, 4, FuncType, true, true, 3, 0, false, OldFunc);
 
     // Function body