Disallow duplication of imported entities

[aaboud]

Summary

Fixed DIBuilder to verify that same imported entity will not be added twice to the "imports" list of the DICompileUnit.

[aaboud]

I will add the following test: Clang/test/Codegen/debug-info-imported-entity.cpp

// RUN: %clang_cc1 -triple x86_64-unk-unk -o - -emit-llvm -debug-info-kind=limited %s | FileCheck %s

namespace std { class A; }
using std::A; using ::A;

// CHECK: [[CompileUnit:![0-9]+]] = distinct !DICompileUnit({{.+}} imports: [[Imports:![0-9]+]])
// CHECK: [[Imports]] = !{[[ImportedEntity:![0-9]+]]}
// CHECK: [[ImportedEntity]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: [[CompileUnit]], entity: !"_ZTSSt1A", line: 4)

[dblaikie]

(please include the fix in the patch for review)

I think the fix could probably happen at a higher level to avoid the linear
search. Perhaps we could get the canonical decl for a using decl - that way
a redecl wouldn't be a 'new' thing? I suppose we'd still need a map of
them, that perhaps we don't have already.

[aprantl]

That, or we make AllImportedUnits a SmallSet (which is arguably more expensive).

[aaboud]

In D17884#368253, @aprantl wrote:

That, or we make AllImportedUnits a SmallSet (which is arguably more expensive).

SmallSet is not good enough, as the order will be arbitrary and we will get non-deterministic order of imported entries that have same context.
I thought to use VectorSet, but it does not have the embrace_push function!

[aaboud]

In D17884#368250, @dblaikie wrote:

(please include the fix in the patch for review)

I am not sure what this comment mean!
What do you want me to include in the patch?

[aprantl]

The confusion probably comes from the fact that the test is in CFE, but the change is in LLVM. Maybe it would make sense to also add a unittest. We have a couple for DIBuilder.

[hintonda]

lib/IR/DIBuilder.cpp

172

Since these are maintained in a DenseMap in LLVMContextImpl, which is already unique, is there a way to use that directly instead of maintaining an additional vector?

[hintonda]

It's actually a DenseSet, which makes it even easier. Here's a partial diff -- the rest is just removing references to AllImportedModules.

diff --git a/lib/IR/DIBuilder.cpp b/lib/IR/DIBuilder.cpp
index b7841fe..9288207 100644
--- a/lib/IR/DIBuilder.cpp
+++ b/lib/IR/DIBuilder.cpp
@@ -19,6 +19,7 @@
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
+#include "LLVMContextImpl.h"

 using namespace llvm;
 using namespace llvm::dwarf;
@@ -110,10 +111,10 @@ void DIBuilder::finalize() {
   if (!AllGVs.empty())
     CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));

-  if (!AllImportedModules.empty())
+  if (!VMContext.pImpl->DIImportedEntitys.empty())
     CUNode->replaceImportedEntities(MDTuple::get(
-        VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
-                                               AllImportedModules.end())));
+        VMContext, SmallVector<Metadata *, 16>(VMContext.pImpl->DIImportedEntitys.begin(),
+                                               VMContext.pImpl->DIImportedEntitys.end())));

[aaboud]

In D17884#368482, @hintonda wrote:

It's actually a DenseSet, which makes it even easier. Here's a partial diff -- the rest is just removing references to AllImportedModules.

diff --git a/lib/IR/DIBuilder.cpp b/lib/IR/DIBuilder.cpp
index b7841fe..9288207 100644
--- a/lib/IR/DIBuilder.cpp
+++ b/lib/IR/DIBuilder.cpp
@@ -19,6 +19,7 @@
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
+#include "LLVMContextImpl.h"

 using namespace llvm;
 using namespace llvm::dwarf;
@@ -110,10 +111,10 @@ void DIBuilder::finalize() {
   if (!AllGVs.empty())
     CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));

-  if (!AllImportedModules.empty())
+  if (!VMContext.pImpl->DIImportedEntitys.empty())
     CUNode->replaceImportedEntities(MDTuple::get(
-        VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
-                                               AllImportedModules.end())));
+        VMContext, SmallVector<Metadata *, 16>(VMContext.pImpl->DIImportedEntitys.begin(),
+                                               VMContext.pImpl->DIImportedEntitys.end())));

It is still a set that has non-deterministic order, i.e. the order of the metadata will be different from one run to another...impossible for testing and might add more unwanted results...
The only solution is to have a VectorSet, or a vector + a Set.

[hintonda]

Could you use a SetVector or SmallSetVector instead of a DenseSet for DIImportedEntities? It's equivalent to what you've proposed, but since it knows when it inserts a new one, maintaining the vector is much cheaper.

[aaboud]

Another try to verify that we add imported entity only once.
This is the cheapest solution, though it might not be elegant enough.

Also, added a unittest to check same imported entities are added only once to the "imports" field in DICompileUnit.

[aaboud]

Another try, this time I am uploading suggested solution by Don Hinton.
He is suggesting to make "imports" field in DICompileUnit of new type "unique vector".
Then we can get rid of AllImportedEntitys container and use directly the LLVMContext::impl::DIImportedEntitys instead

[dblaikie]

Pretty sure we shouldn't be adding things to LLVMContext for this, but I
haven't looked closely at the patch/followed the discussion that got us
there in the first place. Will come back to this when I get a chance
(probably later this week) but I'm mentioning it in case others
reading/interacting on the thread can figure it out before then.

[aaboud]

In D17884#369172, @dblaikie wrote:

Pretty sure we shouldn't be adding things to LLVMContext for this, but I
haven't looked closely at the patch/followed the discussion that got us
there in the first place. Will come back to this when I get a chance
(probably later this week) but I'm mentioning it in case others
reading/interacting on the thread can figure it out before then.

Thanks David,
Please, when you have time to review this, check also patch 49934 (Diff 2).
It is a simpler solution, but not sure also that it is the right one.

[aaboud]

I just figure out why this approach will not work.
The idea here was to get rid of AllImportedModules list and use the DIImportedEntitys list from the LLVMContextImpl class, assuming that they contain the same info, which is wrong.
AllImportedModules list is per DICompileUnit, while DIImportedEntitys contains all the imported entities from all Compile units.

We cannot get rid of AllImportedModules, thus I will revert this patch to Diff 2.

[aaboud]

Reverting the patch to Diff 2.

[hintonda]

Good catch. LGTM...

[dblaikie]

I'm confused. This patch looks like it's missing parts - there is no DIImportedEntitys (btw: should be DIImportedEntities, if it does exist/is added) in the LLVMContext in trunk at the moment. This patch seems to use it, but doesn't introduce it. Should I be looking elsewhere, at some preparatory patch?

[hintonda]

It's an instance of the X Macro technique. In this case:

lib/IR/LLVMContextImp.h: 937
#define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
  DenseSet<CLASS *, CLASS##Info> CLASS##s;
#include "llvm/IR/Metadata.def"

include/llvm/IR/Metadata.def: 110
HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)

[dblaikie]

Seems like a bit more an implementation detail than we'd really want to depend on, but the cost is so low & isolated, & it's so inobtrusive that if/when this does change, it's not going to cost us anymore to fix it then than it would to fix it now so let's go with it.

Please commit when ready.

include/llvm/ADT/SetVector.h

reverse_iterator rend() {
     return vector_.rend();
   }
 
   /// \brief Get a const_reverse_iterator to the beginning of the SetVector.
   const_reverse_iterator rend() const {
     return vector_.rend();
   }
 
+  /// Get underlying set container of the SetVector.
+  const set_type &set() const {
+    return set_;
+  }
+
   /// \brief Return the last element of the SetVector.
   const T &back() const {
     assert(!empty() && "Cannot call back() on empty SetVector!");
     return vector_.back();
   }
 
   /// \brief Index into the SetVector.
   const_reference operator[](size_type n) const {

include/llvm/IR/Metadata.def

 //===- llvm/IR/Metadata.def - Metadata definitions --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // Macros for running through all types of metadata.
 //
 //===----------------------------------------------------------------------===//
 
 #if !(defined HANDLE_METADATA || defined HANDLE_METADATA_LEAF ||               \
       defined HANDLE_METADATA_BRANCH || defined HANDLE_MDNODE_LEAF ||          \
-      defined HANDLE_MDNODE_LEAF_UNIQUABLE || defined HANDLE_MDNODE_BRANCH ||  \
+      defined HANDLE_MDNODE_LEAF_UNIQUABLE ||                                  \
+      defined HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR ||                           \
+      defined HANDLE_MDNODE_BRANCH ||                                          \
       defined HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE ||                      \
       defined HANDLE_SPECIALIZED_MDNODE_LEAF ||                                \
       defined HANDLE_SPECIALIZED_MDNODE_BRANCH)
 #error "Missing macro definition of HANDLE_METADATA*"
 #endif
 
 // Handler for all types of metadata.
 #ifndef HANDLE_METADATA

 #endif
 #endif
 
 // Handler for leaf nodes under MDNode.
 #ifndef HANDLE_MDNODE_LEAF_UNIQUABLE
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS) HANDLE_MDNODE_LEAF(CLASS)
 #endif
 
+#ifndef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE_VECTOR
+#ifdef HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR
+#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS)                 \
+  HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS)
+#else
+#define HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS)                 \
+  HANDLE_SPECIALIZED_MDNODE_LEAF(CLASS)
+#endif
+#endif
+
+// Handler for leaf nodes under MDNode.
+#ifndef HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR
+#define HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS) HANDLE_MDNODE_LEAF(CLASS)
+#endif
+
 // Handler for leaf nodes under MDNode.
 #ifndef HANDLE_MDNODE_LEAF
 #define HANDLE_MDNODE_LEAF(CLASS) HANDLE_METADATA_LEAF(CLASS)
 #endif
 
 // Handler for non-leaf nodes under MDNode.
 #ifndef HANDLE_MDNODE_BRANCH
 #define HANDLE_MDNODE_BRANCH(CLASS) HANDLE_METADATA_BRANCH(CLASS)

 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIModule)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DITemplateParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateTypeParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateValueParameter)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIObjCProperty)
-HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE_VECTOR(DIImportedEntity)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
 
 #undef HANDLE_METADATA
 #undef HANDLE_METADATA_LEAF
 #undef HANDLE_METADATA_BRANCH
 #undef HANDLE_MDNODE_LEAF
 #undef HANDLE_MDNODE_LEAF_UNIQUABLE
+#undef HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR
 #undef HANDLE_MDNODE_BRANCH
 #undef HANDLE_SPECIALIZED_MDNODE_LEAF
 #undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE
+#undef HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE_VECTOR
 #undef HANDLE_SPECIALIZED_MDNODE_BRANCH

lib/IR/DIBuilder.cpp

 #include "llvm/IR/DIBuilder.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
+#include "LLVMContextImpl.h"
 
 using namespace llvm;
 using namespace llvm::dwarf;
 
 namespace {
 class HeaderBuilder {
   /// \brief Whether there are any fields yet.
   ///
if (MDTuple *Temp = SP->getVariables().get()) {
       DINodeArray AV = getOrCreateArray(Variables);
       TempMDTuple(Temp)->replaceAllUsesWith(AV.get());
     }
   }
 
   if (!AllGVs.empty())
     CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));
 
-  if (!AllImportedModules.empty())
+  if (!VMContext.pImpl->DIImportedEntitys.empty())
     CUNode->replaceImportedEntities(MDTuple::get(
-        VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
-                                               AllImportedModules.end())));
+        VMContext, SmallVector<Metadata *, 16>(
+            VMContext.pImpl->DIImportedEntitys.begin(),
+            VMContext.pImpl->DIImportedEntitys.end())));
 
   // Now that all temp nodes have been replaced or deleted, resolve remaining
   // cycles.
   for (const auto &N : UnresolvedNodes)
     if (N && !N->isResolved())
       N->resolveCycles();
   UnresolvedNodes.clear();
 
DICompileUnit *DIBuilder::createCompileUnit(
   }
 
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 
 static DIImportedEntity *
 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context,
-                     Metadata *NS, unsigned Line, StringRef Name,
-                     SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
+                     Metadata *NS, unsigned Line, StringRef Name) {
   auto *M = DIImportedEntity::get(C, Tag, Context, DINodeRef(NS), Line, Name);
-  AllImportedModules.emplace_back(M);
   return M;
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DINamespace *NS,
                                                   unsigned Line) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
-                                Context, NS, Line, StringRef(), AllImportedModules);
+                                Context, NS, Line, StringRef());
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DIImportedEntity *NS,
                                                   unsigned Line) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
-                                Context, NS, Line, StringRef(), AllImportedModules);
+                                Context, NS, Line, StringRef());
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M,
                                                   unsigned Line) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
-                                Context, M, Line, StringRef(), AllImportedModules);
+                                Context, M, Line, StringRef());
 }
 
 DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context,
                                                        DINode *Decl,
                                                        unsigned Line,
                                                        StringRef Name) {
   // Make sure to use the unique identifier based metadata reference for
   // types that have one.
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
-                                Context, DINodeRef::get(Decl), Line, Name,
-                                AllImportedModules);
+                                Context, DINodeRef::get(Decl), Line, Name);
 }
 
 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory) {
   return DIFile::get(VMContext, Filename, Directory);
 }
 
 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val) {
   assert(!Name.empty() && "Unable to create enumerator without name");

lib/IR/LLVMContextImpl.h

 #include "ConstantsContext.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/ValueHandle.h"
public:
   StringMap<MDString> MDStringCache;
   DenseMap<Value *, ValueAsMetadata *> ValuesAsMetadata;
   DenseMap<Metadata *, MetadataAsValue *> MetadataAsValues;
 
   DenseMap<const Value*, ValueName*> ValueNames;
 
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   DenseSet<CLASS *, CLASS##Info> CLASS##s;
+#define HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS)                             \
+  SetVector<CLASS *, std::vector<CLASS *>, DenseSet<CLASS *, CLASS##Info> >    \
+      CLASS##s;
 #include "llvm/IR/Metadata.def"
 
   // MDNodes may be uniqued or not uniqued.  When they're not uniqued, they
   // aren't in the MDNodeSet, but they're still shared between objects, so no
   // one object can destroy them.  This set allows us to at least destroy them
   // on Context destruction.
   SmallPtrSet<MDNode *, 1> DistinctMDNodes;
 

lib/IR/Metadata.cpp

 static T *uniquifyImpl(T *N, DenseSet<T *, InfoT> &Store) {
   if (T *U = getUniqued(Store, N))
     return U;
 
   Store.insert(N);
   return N;
 }
 
+template <class T, class InfoT>
+static T *uniquifyImpl(T *N, SetVector < T *, std::vector<T *>,
+                       DenseSet<T *, InfoT >> &Store) {
+  if (T *U = getUniqued(Store, N))
+    return U;
+  Store.insert(N);
+  return N;
+}
+
 template <class NodeTy> struct MDNode::HasCachedHash {
   typedef char Yes[1];
   typedef char No[2];
   template <class U, U Val> struct SFINAE {};
 
   template <class U>
   static Yes &check(SFINAE<void (U::*)(unsigned), &U::setHash> *);
   template <class U> static No &check(...);

 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   case CLASS##Kind: {                                                          \
     CLASS *SubclassThis = cast<CLASS>(this);                                   \
     std::integral_constant<bool, HasCachedHash<CLASS>::value>                  \
         ShouldRecalculateHash;                                                 \
     dispatchRecalculateHash(SubclassThis, ShouldRecalculateHash);              \
     return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s);           \
   }
+#define HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS)                             \
+  case CLASS##Kind: {                                                          \
+    CLASS *SubclassThis = cast<CLASS>(this);                                   \
+    std::integral_constant<bool, HasCachedHash<CLASS>::value>                  \
+        ShouldRecalculateHash;                                                 \
+    dispatchRecalculateHash(SubclassThis, ShouldRecalculateHash);              \
+    return uniquifyImpl(SubclassThis, getContext().pImpl->CLASS##s);           \
+  }
 #include "llvm/IR/Metadata.def"
   }
 }
 
 void MDNode::eraseFromStore() {
   switch (getMetadataID()) {
   default:
     llvm_unreachable("Invalid or non-uniquable subclass of MDNode");
 #define HANDLE_MDNODE_LEAF_UNIQUABLE(CLASS)                                    \
   case CLASS##Kind:                                                            \
     getContext().pImpl->CLASS##s.erase(cast<CLASS>(this));                     \
     break;
+#define HANDLE_MDNODE_LEAF_UNIQUABLE_VECTOR(CLASS)                             \
+  case CLASS##Kind:                                                            \
+    getContext().pImpl->CLASS##s.remove(cast<CLASS>(this));                    \
+    break;
 #include "llvm/IR/Metadata.def"
   }
 }
 
 MDTuple *MDTuple::getImpl(LLVMContext &Context, ArrayRef<Metadata *> MDs,
                           StorageType Storage, bool ShouldCreate) {
   unsigned Hash = 0;
   if (Storage == Uniqued) {

lib/IR/MetadataImpl.h

 
 template <class T, class InfoT>
 static T *getUniqued(DenseSet<T *, InfoT> &Store,
                      const typename InfoT::KeyTy &Key) {
   auto I = Store.find_as(Key);
   return I == Store.end() ? nullptr : *I;
 }
 
+template <class T, class InfoT>
+static T *
+getUniqued(SetVector<T *, std::vector<T *>, DenseSet<T *, InfoT>> &Store,
+const typename InfoT::KeyTy &Key) {
+  auto I = Store.set().find_as(Key);
+  return I == Store.set().end() ? nullptr : *I;
+}
+
 template <class T> T *MDNode::storeImpl(T *N, StorageType Storage) {
   switch (Storage) {
   case Uniqued:
     llvm_unreachable("Cannot unique without a uniquing-store");
   case Distinct:
     N->storeDistinctInContext();
     break;
   case Temporary:

unittests/IR/IRBuilderTest.cpp

TEST_F(IRBuilderTest, DebugLoc) {
   Call1->setDebugLoc(DL2);
   Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());
   EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
   auto Call2 = Builder.CreateCall(Callee, None);
   EXPECT_EQ(DL2, Call2->getDebugLoc());
 
   DIB.finalize();
 }
+
+TEST_F(IRBuilderTest, DIImportedEntity) {
+  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 IE1 = DIB.createImportedDeclaration(CU, nullptr, 1);
+  auto IE2 = DIB.createImportedDeclaration(CU, nullptr, 1);
+  auto IE3 = DIB.createImportedModule(CU, (DIImportedEntity*)nullptr, 2);
+  auto IE4 = DIB.createImportedModule(CU, (DIImportedEntity*)nullptr, 2);
+  DIB.finalize();
+  EXPECT_TRUE(verifyModule(*M));
+  EXPECT_TRUE(CU->getImportedEntities().size() == 2);
+}
 }