Emit struct & class TypeInfos incl. vtables into each referencing CU

Author: kinke

gen/classes.cpp

@@ -56,7 +56,7 @@ void DtoResolveClass(ClassDeclaration *cd) {
   DtoType(cd->type);
 
   // create IrAggr
-  IrClass *irAggr = getIrAggr(cd, true);
+  getIrAggr(cd, true);
 
   // make sure all fields really get their ir field
   for (auto vd : cd->fields) {
@@ -67,11 +67,6 @@ void DtoResolveClass(ClassDeclaration *cd) {
     }
     getIrField(vd, true);
   }
-
-  // interface only emit typeinfo and classinfo
-  if (cd->isInterfaceDeclaration()) {
-    irAggr->initializeInterface();
-  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

gen/functions.cpp

@@ -566,10 +566,9 @@ void DtoDeclareFunction(FuncDeclaration *fdecl, const bool willDefine) {
   // Check if fdecl should be defined too for cross-module inlining.
   // If true, semantic is fully done for fdecl which is needed for some code
   // below (e.g. code that uses fdecl->vthis).
-  bool defineAtEnd;
+  bool defineAtEnd = false;
   bool defineAsAvailableExternally = false;
   if (willDefine) {
-    defineAtEnd = false;
   } else if (DtoIsTemplateInstance(fdecl)) {
     if (fdecl->semanticRun < PASSsemantic3done) {
       assert(fdecl->functionSemantic3());

gen/rttibuilder.cpp

@@ -64,10 +64,6 @@ void RTTIBuilder::push_null_vp() { push(getNullValue(getVoidPtrType())); }
 
 void RTTIBuilder::push_typeinfo(Type *t) { push(DtoTypeInfoOf(t)); }
 
-void RTTIBuilder::push_classinfo(ClassDeclaration *cd) {
-  push(getIrAggr(cd)->getClassInfoSymbol());
-}
-
 void RTTIBuilder::push_string(const char *str) { push(DtoConstString(str)); }
 
 void RTTIBuilder::push_null_void_array() {

gen/rttibuilder.h

@@ -46,7 +46,6 @@ class RTTIBuilder {
   void push_size_as_vp(uint64_t s);
   void push_string(const char *str);
   void push_typeinfo(Type *t);
-  void push_classinfo(ClassDeclaration *cd);
 
   /// pushes the function pointer or a null void* if it cannot.
   void push_funcptr(FuncDeclaration *fd, Type *castto = nullptr);

gen/typinf.cpp

@@ -299,7 +299,7 @@ class DefineVisitor : public Visitor {
     RTTIBuilder b(getInterfaceTypeInfoType());
 
     // TypeInfo base
-    b.push_classinfo(tc->sym);
+    b.push_typeinfo(tc);
 
     // finish
     b.finalize(gvar);
@@ -503,10 +503,10 @@ LLGlobalVariable *DtoResolveTypeInfo(TypeInfoDeclaration *tid) {
   assert(!gIR->dcomputetarget);
 
   if (!tid->ir->isResolved()) {
-    tid->ir->setResolved();
-
     DeclareOrDefineVisitor v;
     tid->accept(&v);
+
+    tid->ir->setResolved();
   }
 
   return llvm::cast<LLGlobalVariable>(getIrValue(tid));

ir/iraggr.cpp

@@ -174,12 +174,9 @@ IrAggr::createInitializerConstant(const VarInitMap &explicitInitializers) {
     }
   }
 
-  // Add the initializers for the member fields. While we are traversing the
-  // class hierarchy, use the opportunity to populate interfacesWithVtbls if
-  // we haven't done so previously (due to e.g. ClassReferenceExp, we can
-  // have multiple initializer constants for a single class).
-  addFieldInitializers(constants, explicitInitializers, aggrdecl, offset,
-                       irClass && irClass->interfacesWithVtbls.empty());
+  // Add the initializers for the member fields.
+  unsigned dummy = 0;
+  addFieldInitializers(constants, explicitInitializers, aggrdecl, offset, dummy);
 
   // tail padding?
   const size_t structsize = aggrdecl->size(Loc());
@@ -218,12 +215,11 @@ IrAggr::createInitializerConstant(const VarInitMap &explicitInitializers) {
 void IrAggr::addFieldInitializers(
     llvm::SmallVectorImpl<llvm::Constant *> &constants,
     const VarInitMap &explicitInitializers, AggregateDeclaration *decl,
-    unsigned &offset, bool populateInterfacesWithVtbls) {
-
+    unsigned &offset, unsigned &interfaceVtblIndex) {
   if (ClassDeclaration *cd = decl->isClassDeclaration()) {
     if (cd->baseClass) {
       addFieldInitializers(constants, explicitInitializers, cd->baseClass,
-                           offset, populateInterfacesWithVtbls);
+                           offset, interfaceVtblIndex);
     }
 
     // has interface vtbls?
@@ -237,14 +233,10 @@ void IrAggr::addFieldInitializers(
       }
 
       IrClass *irClass = static_cast<IrClass *>(this);
-      size_t inter_idx = irClass->interfacesWithVtbls.size();
       for (auto bc : *cd->vtblInterfaces) {
-        constants.push_back(irClass->getInterfaceVtblSymbol(bc, inter_idx));
+        constants.push_back(irClass->getInterfaceVtblSymbol(bc, interfaceVtblIndex));
         offset += target.ptrsize;
-        inter_idx++;
-
-        if (populateInterfacesWithVtbls)
-          irClass->interfacesWithVtbls.push_back(bc);
+        ++interfaceVtblIndex;
       }
     }
   }

ir/iraggr.h

@@ -103,7 +103,7 @@ class IrAggr {
   void addFieldInitializers(llvm::SmallVectorImpl<llvm::Constant *> &constants,
                             const VarInitMap &explicitInitializers,
                             AggregateDeclaration *decl, unsigned &offset,
-                            bool populateInterfacesWithVtbls);
+                            unsigned &interfaceVtblIndex);
 };
 
 /// Represents a struct.
@@ -122,7 +122,7 @@ class IrStruct : public IrAggr {
 /// Represents a class/interface.
 class IrClass : public IrAggr {
 public:
-  explicit IrClass(ClassDeclaration *cd) : IrAggr(cd) {}
+  explicit IrClass(ClassDeclaration *cd);
 
   /// Creates the __ClassZ/__InterfaceZ symbol lazily.
   llvm::GlobalVariable *getClassInfoSymbol(bool define = false);
@@ -133,9 +133,6 @@ class IrClass : public IrAggr {
   /// Defines all interface vtbls.
   void defineInterfaceVtbls();
 
-  /// Initialize interface.
-  void initializeInterface();
-
 private:
   /// Vtbl global.
   llvm::GlobalVariable *vtbl = nullptr;
@@ -157,6 +154,8 @@ class IrClass : public IrAggr {
   /// Corresponds to the Interface instances needed to be output.
   std::vector<BaseClass *> interfacesWithVtbls;
 
+  void addInterfaceVtbls(ClassDeclaration *cd);
+
   /// Builds the __ClassZ/__InterfaceZ initializer constant lazily.
   llvm::Constant *getClassInfoInit();
 

ir/irclass.cpp

@@ -41,6 +41,28 @@
 
 //////////////////////////////////////////////////////////////////////////////
 
+IrClass::IrClass(ClassDeclaration *cd) : IrAggr(cd) {
+  addInterfaceVtbls(cd);
+
+  assert(interfacesWithVtbls.size() ==
+             stripModifiers(type)->ctype->isClass()->getNumInterfaceVtbls() &&
+         "inconsistent number of interface vtables in this class");
+}
+
+void IrClass::addInterfaceVtbls(ClassDeclaration *cd) {
+  if (cd->baseClass && !cd->isInterfaceDeclaration()) {
+    addInterfaceVtbls(cd->baseClass);
+  }
+
+  if (cd->vtblInterfaces) {
+    for (auto bc : *cd->vtblInterfaces) {
+      interfacesWithVtbls.push_back(bc);
+    }
+  }
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
 LLGlobalVariable *IrClass::getVtblSymbol(bool define) {
   if (!vtbl) {
     const auto irMangle = getIRMangledVTableSymbolName(aggrdecl);
@@ -108,12 +130,15 @@ LLGlobalVariable *IrClass::getClassInfoSymbol(bool define) {
       node->addOperand(llvm::MDNode::get(
           gIR->context(), llvm::makeArrayRef(mdVals, CD_NumFields)));
     }
+
+    if (!define && DtoIsTemplateInstance(aggrdecl))
+      define = true;
   }
 
   if (define) {
     auto init = getClassInfoInit();
     if (!typeInfo->hasInitializer())
-      defineGlobal(typeInfo, init, aggrdecl, true);
+      defineGlobal(typeInfo, init, aggrdecl);
   }
 
   return typeInfo;
@@ -361,7 +386,7 @@ LLConstant *IrClass::getClassInfoInit() {
   // TypeInfo_Class base
   assert(!isInterface || !cd->baseClass);
   if (cd->baseClass) {
-    b.push_classinfo(cd->baseClass);
+    b.push_typeinfo(cd->baseClass->type);
   } else {
     b.push_null(cinfoType);
   }
@@ -711,9 +736,7 @@ LLConstant *IrClass::getClassInfoInterfaces() {
     if (cd->isInterfaceDeclaration()) {
       vtb = DtoConstSlice(DtoConstSize_t(0), getNullValue(voidptrptr_type));
     } else {
-      auto itv = interfaceVtblMap.find({it->sym, i});
-      assert(itv != interfaceVtblMap.end() && "interface vtbl not found");
-      vtb = itv->second;
+      vtb = getInterfaceVtblSymbol(it, i);
       vtb = DtoBitCast(vtb, voidptrptr_type);
       auto vtblSize = itc->getVtblType()->getNumContainedTypes();
       vtb = DtoConstSlice(DtoConstSize_t(vtblSize), vtb);
@@ -735,7 +758,7 @@ LLConstant *IrClass::getClassInfoInterfaces() {
   // create and apply initializer
   LLConstant *arr = LLConstantArray::get(array_type, constants);
   auto ciarr = getInterfaceArraySymbol();
-  defineGlobal(ciarr, arr, cd, true);
+  defineGlobal(ciarr, arr, cd);
 
   // return null, only baseclass provide interfaces
   if (cd->vtblInterfaces->length == 0) {
@@ -753,20 +776,3 @@ LLConstant *IrClass::getClassInfoInterfaces() {
   // return as a slice
   return DtoConstSlice(DtoConstSize_t(cd->vtblInterfaces->length), ptr);
 }
-
-//////////////////////////////////////////////////////////////////////////////
-
-void IrClass::initializeInterface() {
-  InterfaceDeclaration *base = aggrdecl->isInterfaceDeclaration();
-  assert(base && "not interface");
-
-  // has interface vtbls?
-  if (!base->vtblInterfaces) {
-    return;
-  }
-
-  for (auto bc : *base->vtblInterfaces) {
-    // add to the interface list
-    interfacesWithVtbls.push_back(bc);
-  }
-}

ir/irstruct.cpp

@@ -52,12 +52,15 @@ LLGlobalVariable* IrStruct::getTypeInfoSymbol(bool define) {
                              getTypeInfoStructMemType(), irMangle, false);
 
     emitTypeInfoMetadata(typeInfo, aggrdecl->type);
+
+    if (!define && DtoIsTemplateInstance(aggrdecl))
+      define = true;
   }
 
   if (define) {
     auto init = getTypeInfoInit();
     if (!typeInfo->hasInitializer())
-      defineGlobal(typeInfo, init, aggrdecl, true);
+      defineGlobal(typeInfo, init, aggrdecl);
   }
 
   return typeInfo;