Use CharUnits values for Size and DataSize outside of the bitfield layout

methods, when they are known to be exact multiples of the width of the char
type. 


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

1 files changed, 19 insertions, 23 deletions

diff --git a/lib/AST/RecordLayoutBuilder.cpp b/lib/AST/RecordLayoutBuilder.cpp
index 4ed031f974..143758f086 100644
--- a/lib/AST/RecordLayoutBuilder.cpp
+++ b/lib/AST/RecordLayoutBuilder.cpp
@@ -815,8 +815,8 @@ void RecordLayoutBuilder::DeterminePrimaryBase(const CXXRecordDecl *RD) {
   assert(DataSize == 0 && "Vtable pointer must be at offset zero!");
 
   // Update the size.
-  setSize(getSizeInBits() + GetVirtualPointersSize(RD));
-  setDataSize(getSizeInBits());
+  setSize(getSize() + Context.toCharUnitsFromBits(GetVirtualPointersSize(RD)));
+  setDataSize(getSize());
 
   CharUnits UnpackedBaseAlign = 
     Context.toCharUnitsFromBits(Context.Target.getPointerAlign(0));
@@ -1108,8 +1108,7 @@ CharUnits RecordLayoutBuilder::LayoutBase(const BaseSubobjectInfo *Base) {
   // If we have an empty base class, try to place it at offset 0.
   if (Base->Class->isEmpty() &&
       EmptySubobjects->CanPlaceBaseAtOffset(Base, CharUnits::Zero())) {
-    uint64_t RecordSizeInBits = Context.toBits(Layout.getSize());
-    setSize(std::max(getSizeInBits(), RecordSizeInBits));
+    setSize(std::max(getSize(), Layout.getSize()));
 
     return CharUnits::Zero();
   }
@@ -1124,27 +1123,24 @@ CharUnits RecordLayoutBuilder::LayoutBase(const BaseSubobjectInfo *Base) {
   }
 
   // Round up the current record size to the base's alignment boundary.
-  uint64_t Offset = 
-    llvm::RoundUpToAlignment(getDataSizeInBits(), Context.toBits(BaseAlign));
+  CharUnits Offset = getDataSize().RoundUpToAlignment(BaseAlign);
 
   // Try to place the base.
-  while (!EmptySubobjects->CanPlaceBaseAtOffset(Base, 
-                                          Context.toCharUnitsFromBits(Offset)))
-    Offset += Context.toBits(BaseAlign);
+  while (!EmptySubobjects->CanPlaceBaseAtOffset(Base, Offset))
+    Offset += BaseAlign;
 
   if (!Base->Class->isEmpty()) {
     // Update the data size.
-    setDataSize(Offset + Context.toBits(Layout.getNonVirtualSize()));
+    setDataSize(Offset + Layout.getNonVirtualSize());
 
-    setSize(std::max(getSizeInBits(), getDataSizeInBits()));
+    setSize(std::max(getSize(), getDataSize()));
   } else
-    setSize(std::max(getSizeInBits(), 
-                     Offset + Context.toBits(Layout.getSize())));
+    setSize(std::max(getSize(), Offset + Layout.getSize()));
 
   // Remember max struct/class alignment.
   UpdateAlignment(BaseAlign, UnpackedBaseAlign);
 
-  return Context.toCharUnitsFromBits(Offset);
+  return Offset;
 }
 
 void RecordLayoutBuilder::InitializeLayout(const Decl *D) {
@@ -1233,7 +1229,7 @@ void RecordLayoutBuilder::Layout(const ObjCInterfaceDecl *D) {
     // We start laying out ivars not at the end of the superclass
     // structure, but at the next byte following the last field.
     setSize(SL.getDataSize());
-    setDataSize(getSizeInBits());
+    setDataSize(getSize());
   }
 
   InitializeLayout(D);
@@ -1483,14 +1479,13 @@ void RecordLayoutBuilder::LayoutField(const FieldDecl *D) {
                     Context.toBits(UnpackedFieldAlign), FieldPacked, D);
 
   // Reserve space for this field.
-  uint64_t FieldSizeInBits = Context.toBits(FieldSize);
   if (IsUnion)
-    setSize(std::max(getSizeInBits(), FieldSizeInBits));
+    setSize(std::max(getSize(), FieldSize));
   else
-    setSize(Context.toBits(FieldOffset) + FieldSizeInBits);
+    setSize(FieldOffset + FieldSize);
 
   // Update the data size.
-  setDataSize(getSizeInBits());
+  setDataSize(getSize());
 
   // Remember max struct/class alignment.
   UpdateAlignment(FieldAlign, UnpackedFieldAlign);
@@ -1504,17 +1499,18 @@ void RecordLayoutBuilder::FinishLayout(const NamedDecl *D) {
       // which is not empty but of size 0; such as having fields of
       // array of zero-length, remains of Size 0
       if (RD->isEmpty())
-        setSize(8);
+        setSize(CharUnits::One());
     }
     else
-      setSize(8);
+      setSize(CharUnits::One());
   }
   // Finally, round the size of the record up to the alignment of the
   // record itself.
   uint64_t UnpaddedSize = getSizeInBits() - UnfilledBitsInLastByte;
-  uint64_t UnpackedSize = 
+  uint64_t UnpackedSizeInBits = 
     llvm::RoundUpToAlignment(getSizeInBits(), 
                              Context.toBits(UnpackedAlignment));
+  CharUnits UnpackedSize = Context.toCharUnitsFromBits(UnpackedSizeInBits);
   setSize(llvm::RoundUpToAlignment(getSizeInBits(), Context.toBits(Alignment)));
 
   unsigned CharBitNum = Context.Target.getCharWidth();
@@ -1536,7 +1532,7 @@ void RecordLayoutBuilder::FinishLayout(const NamedDecl *D) {
     // Warn if we packed it unnecessarily. If the alignment is 1 byte don't
     // bother since there won't be alignment issues.
     if (Packed && UnpackedAlignment > CharUnits::One() && 
-        getSizeInBits() == UnpackedSize)
+        getSize() == UnpackedSize)
       Diag(D->getLocation(), diag::warn_unnecessary_packed)
           << Context.getTypeDeclType(RD);
   }