Make GenerateVtable a private member function of CGVtableInfo.

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

diff --git a/lib/CodeGen/CGVtable.cpp b/lib/CodeGen/CGVtable.cpp
index 2ff3e70ea80935118330665fc8527cc0dc401087..b52e5739d599676199a3f47b4168087f1f6356b1 100644 (file)
--- a/lib/CodeGen/CGVtable.cpp
+++ b/lib/CodeGen/CGVtable.cpp
@@ -1111,22 +1111,22 @@ createGlobalVariable(CodeGenModule &CGM, const CXXRecordDecl *RD,
   return V;
 }
 
-llvm::Constant *CodeGenModule::GenerateVtable(const CXXRecordDecl *LayoutClass,
-                                              const CXXRecordDecl *RD,
-                                              uint64_t Offset) {
+llvm::GlobalVariable *
+CGVtableInfo::GenerateVtable(const CXXRecordDecl *LayoutClass,
+                             const CXXRecordDecl *RD, uint64_t Offset) {
   llvm::SmallString<256> OutName;
   if (LayoutClass != RD)
-    getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset/8, RD, OutName);
+    CGM.getMangleContext().mangleCXXCtorVtable(LayoutClass, Offset / 8, 
+                                               RD, OutName);
   else
-    getMangleContext().mangleCXXVtable(RD, OutName);
+    CGM.getMangleContext().mangleCXXVtable(RD, OutName);
   llvm::StringRef Name = OutName.str();
 
-  llvm::Type *Ptr8Ty=llvm::PointerType::get(llvm::Type::getInt8Ty(VMContext),0);
   int64_t AddressPoint;
 
-  llvm::GlobalVariable *GV = getModule().getGlobalVariable(Name);
-  if (GV && AddressPoints[LayoutClass] && !GV->isDeclaration()) {
-    AddressPoint=(*(*(AddressPoints[LayoutClass]))[RD])[std::make_pair(RD,
+  llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name);
+  if (GV && CGM.AddressPoints[LayoutClass] && !GV->isDeclaration()) {
+    AddressPoint=(*(*(CGM.AddressPoints[LayoutClass]))[RD])[std::make_pair(RD,
                                                                        Offset)];
     // FIXME: We can never have 0 address point.  Do this for now so gepping
     // retains the same structure.  Later, we'll just assert.
@@ -1138,7 +1138,7 @@ llvm::Constant *CodeGenModule::GenerateVtable(const CXXRecordDecl *LayoutClass,
       CreateDefinition = true;
     else {
       const ASTRecordLayout &Layout = 
-        getContext().getASTRecordLayout(LayoutClass);
+        CGM.getContext().getASTRecordLayout(LayoutClass);
       
       if (const CXXMethodDecl *KeyFunction = Layout.getKeyFunction()) {
         if (!KeyFunction->getBody()) {
@@ -1149,7 +1149,7 @@ llvm::Constant *CodeGenModule::GenerateVtable(const CXXRecordDecl *LayoutClass,
       }
     }
 
-    VtableBuilder b(RD, LayoutClass, Offset, *this, CreateDefinition);
+    VtableBuilder b(RD, LayoutClass, Offset, CGM, CreateDefinition);
 
     D1(printf("vtable %s\n", RD->getNameAsCString()));
     // First comes the vtables for all the non-virtual bases...
@@ -1159,15 +1159,16 @@ llvm::Constant *CodeGenModule::GenerateVtable(const CXXRecordDecl *LayoutClass,
     b.GenerateVtableForVBases(RD, Offset);
 
     llvm::Constant *Init = 0;
+    const llvm::Type *Int8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
     llvm::ArrayType *ArrayType = 
-      llvm::ArrayType::get(Ptr8Ty, b.getVtable().size());
+      llvm::ArrayType::get(Int8PtrTy, b.getVtable().size());
 
     if (CreateDefinition) {
       Init = llvm::ConstantArray::get(ArrayType, &b.getVtable()[0], 
                                       b.getVtable().size());
     }
     llvm::GlobalVariable *OGV = GV;
-    GV = createGlobalVariable(*this, LayoutClass, ArrayType, Init, Name);
+    GV = createGlobalVariable(CGM, LayoutClass, ArrayType, Init, Name);
     if (OGV) {
       GV->takeName(OGV);
       llvm::Constant *NewPtr = 
@@ -1382,23 +1383,24 @@ llvm::Constant *CodeGenModule::GenerateVTT(const CXXRecordDecl *RD) {
 }
 
 void CGVtableInfo::GenerateClassData(const CXXRecordDecl *RD) {
-  Vtables[RD] = CGM.GenerateVtable(RD, RD);
+  Vtables[RD] = GenerateVtable(RD, RD, 0);
   CGM.GenerateRTTI(RD);
   CGM.GenerateVTT(RD);  
 }
 
-llvm::Constant *CGVtableInfo::getVtable(const CXXRecordDecl *RD) {
-  llvm::Constant *&Vtable = Vtables[RD];
+llvm::GlobalVariable *CGVtableInfo::getVtable(const CXXRecordDecl *RD) {
+  llvm::GlobalVariable *Vtable = Vtables[RD];
+  
   if (!Vtable)
-    Vtable = CGM.GenerateVtable(RD, RD);
+    Vtable = GenerateVtable(RD, RD, 0);
 
   return Vtable;
 }
 
-llvm::Constant *CGVtableInfo::getCtorVtable(const CXXRecordDecl *LayoutClass,
-                                            const CXXRecordDecl *RD,
-                                            uint64_t Offset) {
-  return CGM.GenerateVtable(LayoutClass, RD, Offset);
+llvm::GlobalVariable *
+CGVtableInfo::getCtorVtable(const CXXRecordDecl *LayoutClass,
+                            const CXXRecordDecl *RD, uint64_t Offset) {
+  return GenerateVtable(LayoutClass, RD, Offset);
 }
 
 void CGVtableInfo::MaybeEmitVtable(GlobalDecl GD) {

diff --git a/lib/CodeGen/CGVtable.h b/lib/CodeGen/CGVtable.h
index 86633d4471c1f8c6cd1fd6797dd300696e616e8b..bfffb673aef1d200e5c069887932111f4f9d63d0 100644 (file)
--- a/lib/CodeGen/CGVtable.h
+++ b/lib/CodeGen/CGVtable.h
@@ -18,7 +18,7 @@
 #include "GlobalDecl.h"
 
 namespace llvm {
-  class Constant;
+  class GlobalVariable;
 }
 
 namespace clang {
@@ -79,7 +79,8 @@ class CGVtableInfo {
   typedef llvm::DenseMap<ClassPairTy, int64_t> VirtualBaseClassIndiciesTy;
   VirtualBaseClassIndiciesTy VirtualBaseClassIndicies;
 
-  llvm::DenseMap<const CXXRecordDecl *, llvm::Constant *> Vtables;
+  /// Vtables - All the vtables which have been defined.
+  llvm::DenseMap<const CXXRecordDecl *, llvm::GlobalVariable *> Vtables;
   
   /// NumVirtualFunctionPointers - Contains the number of virtual function 
   /// pointers in the vtable for a given record decl.
@@ -95,7 +96,11 @@ class CGVtableInfo {
   /// upon definition of a KeyFunction.  This includes the vtable, the
   /// rtti data structure and the VTT.
   void GenerateClassData(const CXXRecordDecl *RD);
-  
+ 
+  llvm::GlobalVariable *GenerateVtable(const CXXRecordDecl *LayoutClass,
+                                       const CXXRecordDecl *RD,
+                                       uint64_t Offset);
+    
 public:
   CGVtableInfo(CodeGenModule &CGM)
     : CGM(CGM) { }
@@ -118,9 +123,10 @@ public:
   /// FIXME: This should return a list of address points.
   uint64_t getVtableAddressPoint(const CXXRecordDecl *RD);
   
-  llvm::Constant *getVtable(const CXXRecordDecl *RD);
-  llvm::Constant *getCtorVtable(const CXXRecordDecl *RD,
-                                const CXXRecordDecl *Class, uint64_t Offset);
+  llvm::GlobalVariable *getVtable(const CXXRecordDecl *RD);
+  llvm::GlobalVariable *getCtorVtable(const CXXRecordDecl *RD,
+                                      const CXXRecordDecl *Class, 
+                                      uint64_t Offset);
   
   
   void MaybeEmitVtable(GlobalDecl GD);

diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h
index b0e1b12ed936fbfddcd305d709ec5d282060c975..65ca758405c409d02d117ca0530a50bb306715ab 100644 (file)
--- a/lib/CodeGen/CodeGenModule.h
+++ b/lib/CodeGen/CodeGenModule.h
@@ -212,15 +212,6 @@ public:
   llvm::Constant *GetAddrOfFunction(GlobalDecl GD,
                                     const llvm::Type *Ty = 0);
 
-  /// GenerateVtable - Generate the vtable for the given type.  LayoutClass is
-  /// the class to use for the virtual base layout information.  For
-  /// non-construction vtables, this is always the same as RD.  Offset is the
-  /// offset in bits for the RD object in the LayoutClass, if we're generating a
-  /// construction vtable, otherwise 0.
-  llvm::Constant *GenerateVtable(const CXXRecordDecl *LayoutClass,
-                                 const CXXRecordDecl *RD,
-                                 uint64_t Offset=0);
-
   /// GenerateVTT - Generate the VTT for the given type.
   llvm::Constant *GenerateVTT(const CXXRecordDecl *RD);