Refactor D17884 solution to use xmacro idiom

[hintonda]

Summary

As recomended by Amjad, this is a follow on to D17884.

It uses the xmacro idiom and addresses Dave's concerns about relying
on, and exposing, implemetation details.

[dblaikie]

I don't think this is too much of an improvement over what we ended up with - no big deal. Thanks for the example, though.

include/llvm/IR/DebugInfoMetadata.h

static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
                                    bool ShouldCreate = true);
 
   TempDIImportedEntity cloneImpl() const {
     return getTemporary(getContext(), getTag(), getScope(), getEntity(),
                         getLine(), getName());
   }
 
 public:
+  static size_t getSize(LLVMContext &Context);
+
   DEFINE_MDNODE_GET(DIImportedEntity,
                     (unsigned Tag, DIScope *Scope, DINodeRef Entity,
                      unsigned Line, StringRef Name = ""),
                     (Tag, Scope, Entity, Line, Name))
   DEFINE_MDNODE_GET(DIImportedEntity,
                     (unsigned Tag, Metadata *Scope, Metadata *Entity,
                      unsigned Line, MDString *Name),
                     (Tag, Scope, Entity, Line, Name))

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.
   ///
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) {
-  unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size();
+  auto EntitiesCount = DIImportedEntity::getSize(C);
   auto *M = DIImportedEntity::get(C, Tag, Context, DINodeRef(NS), Line, Name);
-  if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
+  if (EntitiesCount < DIImportedEntity::getSize(C))
     // A new Imported Entity was just added to the context.
     // Add it to the Imported Modules list.
     AllImportedModules.emplace_back(M);
   return M;
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DINamespace *NS,

lib/IR/DebugInfoMetadata.cpp

return storeImpl(new (DwarfOps.size() + 1) GenericDINode(
                        Context, Storage, Hash, Tag, PreOps, DwarfOps),
                    Storage, Context.pImpl->GenericDINodes);
 }
 
 void GenericDINode::recalculateHash() {
   setHash(GenericDINodeInfo::KeyTy::calculateHash(this));
 }
 
+#define DEFINE_GETIMPL_SIZE(CLASS) \
+  return Context.pImpl->CLASS##s.size();
 #define UNWRAP_ARGS_IMPL(...) __VA_ARGS__
 #define UNWRAP_ARGS(ARGS) UNWRAP_ARGS_IMPL ARGS
 #define DEFINE_GETIMPL_LOOKUP(CLASS, ARGS)                                     \
   do {                                                                         \
     if (Storage == Uniqued) {                                                  \
       if (auto *N = getUniqued(Context.pImpl->CLASS##s,                        \
                                CLASS##Info::KeyTy(UNWRAP_ARGS(ARGS))))         \
         return N;                                                              \
DIObjCProperty *DIObjCProperty::getImpl(
   assert(isCanonical(SetterName) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIObjCProperty,
                         (getString(Name), File, Line, getString(GetterName),
                          getString(SetterName), Attributes, Type));
   Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
   DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
 }
 
+size_t DIImportedEntity::getSize(LLVMContext &Context) {
+  DEFINE_GETIMPL_SIZE(DIImportedEntity);
+}
+
 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
                                             Metadata *Scope, Metadata *Entity,
                                             unsigned Line, MDString *Name,
                                             StorageType Storage,
                                             bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIImportedEntity,
                         (Tag, Scope, Entity, Line, getString(Name)));