Handle layout of non-virtual base classes.

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

diff --git a/lib/AST/RecordLayoutBuilder.cpp b/lib/AST/RecordLayoutBuilder.cpp
index 41272fdbfead8e0942570d636250b35dff8fde4a..1dcc4f84650f083464416b8e88b1f282df968f9d 100644 (file)
--- a/lib/AST/RecordLayoutBuilder.cpp
+++ b/lib/AST/RecordLayoutBuilder.cpp
@@ -11,6 +11,7 @@
 
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/RecordLayout.h"
@@ -20,9 +21,48 @@
 using namespace clang;
 
 ASTRecordLayoutBuilder::ASTRecordLayoutBuilder(ASTContext &Ctx) 
-  : Ctx(Ctx), Size(0), Alignment(8), StructPacking(0), NextOffset(0), 
+  : Ctx(Ctx), Size(0), Alignment(8), StructPacking(0), NextOffset(0),
   IsUnion(false) {}
 
+void 
+ASTRecordLayoutBuilder::LayoutNonVirtualBases(const CXXRecordDecl *RD) {
+  assert(!RD->isPolymorphic() && 
+         "FIXME: We don't support polymorphic classes yet!");
+  
+  for (CXXRecordDecl::base_class_const_iterator i = RD->bases_begin(),
+       e = RD->bases_end(); i != e; ++i) {
+    if (!i->isVirtual()) {
+      const CXXRecordDecl *Base = 
+        cast<CXXRecordDecl>(i->getType()->getAsRecordType()->getDecl());
+      LayoutNonVirtualBase(Base);
+    }
+  }
+}
+
+void ASTRecordLayoutBuilder::LayoutNonVirtualBase(const CXXRecordDecl *RD) {
+  const ASTRecordLayout &BaseInfo = Ctx.getASTRecordLayout(RD);
+    assert(BaseInfo.getDataSize() > 0 && 
+           "FIXME: Handle empty classes.");
+  
+  // FIXME: Should get the non-virtual alignment of the base.
+  unsigned BaseAlign = BaseInfo.getAlignment();
+  
+  // FIXME: Should get the non-virtual size of the base.
+  uint64_t BaseSize = BaseInfo.getDataSize();
+  
+  // Round up the current record size to the base's alignment boundary.
+  Size = (Size + (BaseAlign-1)) & ~(BaseAlign-1);
+
+  // Reserve space for this base.
+  Size += BaseSize;
+  
+  // Remember the next available offset.
+  NextOffset = Size;
+  
+  // Remember max struct/class alignment.
+  UpdateAlignment(BaseAlign);
+}
+
 void ASTRecordLayoutBuilder::Layout(const RecordDecl *D) {
   IsUnion = D->isUnion();
   
@@ -31,7 +71,11 @@ void ASTRecordLayoutBuilder::Layout(const RecordDecl *D) {
   
   if (const AlignedAttr *AA = D->getAttr<AlignedAttr>())
     UpdateAlignment(AA->getAlignment());
-  
+
+  // If this is a C++ class, lay out the nonvirtual bases.
+  if (Ctx.getLangOptions().CPlusPlus)
+    LayoutNonVirtualBases(cast<CXXRecordDecl>(D));
+
   LayoutFields(D);
   
   // Finally, round the size of the total struct up to the alignment of the
@@ -191,8 +235,20 @@ ASTRecordLayoutBuilder::ComputeLayout(ASTContext &Ctx,
 
   Builder.Layout(D);
 
-  return new ASTRecordLayout(Builder.Size, Builder.Alignment,
-                             Builder.NextOffset,
+  bool IsPODForThePurposeOfLayout;
+  if (!Ctx.getLangOptions().CPlusPlus) {
+    // In C, all record types are POD.
+    IsPODForThePurposeOfLayout = true;
+  } else {
+    // FIXME: This is not always correct. See the part about bitfields at
+    // http://www.codesourcery.com/public/cxx-abi/abi.html#POD for more info.
+    IsPODForThePurposeOfLayout = cast<CXXRecordDecl>(D)->isPOD();
+  }
+  
+  uint64_t DataSize = 
+    IsPODForThePurposeOfLayout ? Builder.Size : Builder.NextOffset;
+  
+  return new ASTRecordLayout(Builder.Size, Builder.Alignment, DataSize,
                              Builder.FieldOffsets.data(), 
                              Builder.FieldOffsets.size());
 }

diff --git a/lib/AST/RecordLayoutBuilder.h b/lib/AST/RecordLayoutBuilder.h
index 4a71b2b0ebb3be5a889533fa61710429e23e0a9c..1545c379016cfabb21eb822bfb5eb1b5889f439e 100644 (file)
--- a/lib/AST/RecordLayoutBuilder.h
+++ b/lib/AST/RecordLayoutBuilder.h
@@ -15,6 +15,7 @@
 namespace clang {
   class ASTContext;
   class ASTRecordLayout;
+  class CXXRecordDecl;
   class FieldDecl;
   class ObjCImplementationDecl;
   class ObjCInterfaceDecl;
@@ -34,12 +35,16 @@ class ASTRecordLayoutBuilder {
   ASTRecordLayoutBuilder(ASTContext &Ctx);
   
   void Layout(const RecordDecl *D);
+  void Layout(const CXXRecordDecl *D);
   void Layout(const ObjCInterfaceDecl *D,
               const ObjCImplementationDecl *Impl);
 
   void LayoutFields(const RecordDecl *D);
   void LayoutField(const FieldDecl *D);
 
+  void LayoutNonVirtualBases(const CXXRecordDecl *RD);
+  void LayoutNonVirtualBase(const CXXRecordDecl *RD);
+  
   /// FinishLayout - Finalize record layout. Adjust record size based on the
   /// alignment.
   void FinishLayout();

diff --git a/test/SemaCXX/class-layout.cpp b/test/SemaCXX/class-layout.cpp
new file mode 100644 (file)
index 0000000..0cb5a6d
--- /dev/null
+++ b/test/SemaCXX/class-layout.cpp
@@ -0,0 +1,31 @@
+// RUN: clang-cc -triple x86_64-unknown-unknown %s -fsyntax-only -verify 
+
+#define SA(n, p) int a##n[(p) ? 1 : -1]
+
+struct A {
+  int a;
+  char b;
+};
+
+SA(0, sizeof(A) == 8);
+
+struct B : A {
+  char c;
+};
+
+SA(1, sizeof(B) == 12);
+
+struct C {
+// Make fields private so C won't be a POD type.
+private:
+  int a;
+  char b;
+};
+
+SA(2, sizeof(C) == 8);
+
+struct D : C {
+  char c;
+};
+
+SA(3, sizeof(D) == 8);